// 目录
/************************** Animate部分 **************************/
// 1. CustomAlert 面向对象实现点击之后展开背景，然后弹出窗口，点击瞬间关闭
// 2. CustomAlertIm 面向对象实现点击之后瞬间展开背景，然后弹出窗口，点击关闭瞬间消失
// 3. showAlert 实现点击之后瞬间展开背景，然后弹出窗口，点击确认、取消、关闭按钮弹窗消失，并支持回调函数
// 4. Lottery 利用面向对象实现使用CSS3 transform和transition实现点击后转盘抽奖的效果
// 5. picFade 使用闭包实现淡入淡出切换图片效果
// 6. countTimeToDate 实现传入目标时间之后，通过计时器实时获取服务器的当前时间，实现倒计时功能，同时将倒计时输入到指定标签中
// 7. countDownTimeAjax 实现传入目标时间之后，通过计时器实时获取服务器的当前时间，实现倒计时功能，同时将倒计时输入到指定标签中
// 8. countDownTime 实现传入目标时间之后，通过计时器实时获取本机的当前时间，实现倒计时功能，同时将倒计时输入到指定标签中
// 9. intervalClass 选取单数或双数的标签，为标签添加类名
// 10. progressBar 与ajaxCore库结合，实现自定义进度条效果
// 11. tabSwitch 使用jQuery实现tab切换
// 12. caseStyle 当标签的值< 0、== 0、> 0时，分别给标签设置样式
// 13. clearHtmlData 批量清空传入数组中所有标签中的内容
// 14. clearHtmlData 批量清空传入数组中所有input输入框中的内容
// 15. countTimeCycle 循环从后台获取倒计时时间开启倒计时，同时可以获取数据填入页面结构中
// 16. addNumBtn 通过加减按钮实现每次进行事件操作之后，加减相应值，并提供回调
// 17. touchScroll 手指或鼠标移入按钮时，判断其所在的按钮位置，移动对应内容区滚动条到相应的位置显示内容
// 18. tap 处理zepto和百度touchjs的tap事件在手指滑动时还会触发的bug
// 19. preventDefault 按照选择器选定的标签阻值默认事件
// 20. stopPropagation 按照选择器选定的标签阻值默认事件
// 21. countDownMM 根据传入的毫秒数，实现倒计时功能
// 22. popup 自定义弹窗，显示遮罩，同时可设置从上下左右是个方向弹出窗口
// 23. pullDown 定义点击展开下拉菜单
// 24. mobileHint 仿APP的提示窗
// 25. cycleHtml 根据传入数组的长度，循环输出结构
// 26. ifDataClass 判断传入的值是否存在内容，若是则返回一个类名，即字符串
// 27. ifArrClass 判断传入的值是否等于说要求的index值，若是则返回一个类名，即字符串
// 28. attrInput 获取标签的属性并将其赋值给input
// 29. htmlInput 获取标签的值并将其赋值给input
// 30. objToAjaxStr 将对象中的属性和属性值改写为适合ajax请求的字符串
// 31. objToAjaxObj 将对象中的属性和属性值改写为适合ajax请求的对象型字符串
// 32. getAjaxObj 创建一个新对象，提取input的attr-data属性中对象的属性名作为新对象的属性名，同时获取input的值为属性值，组合成一个对象，用于赋值给$scope初始化时赋值使用
// 33. createInput 批量创建用于存储页面数据的input输入框
// 34. bindInput 将两个选择器的输入框互相绑定
// 35. bindAttrInput 将ele中的attr属性值赋值给Input输入框
// 36. bindAttrArrInput 将相同index的ele中的attr属性值赋值给Input输入框
// 37. bindHtmlInput 将ele中的html()值赋值给Input输入框
// 38. bindHtmlArrInput 将相同index的ele中的html()值赋值给Input输入框
// 39. bindValInput 将ele中的val()值赋值给Input输入框
// 40. bindValArrInput 将相同index的ele中的val()值赋值给Input输入框
// 41. addSelection 为一列标签添加点击事件，点击之后给定一个类名，默认active，表示被选中，并提供回调函数
// 42. statusSwitch 根据传入的index值，切换标签的类名、内部元素的类名、样式、文字等
// 43. switchBtn 按钮点击之后右滑表示开启，并变换背景色
// 44. muiPicker 结合MUI插件，实现picker载入
// 45. muiDtPicker 结合MUI插件，实现DtPicker载入
// 46. collectData 收集页面中的数据并转换成字符串形式发送ajax请求
// 47. limitTimeArr 根据输入的起始和结束的小时：分钟格式的时间，生成其中每隔30分钟的数组，即起始时间为10:10，则从10:30开始输出
// 48. contentScroll 内容循环滚动
// 49. swiperScroll 使用swiper创建内容滚动，避免iOS滚动困难
// 50. resetTranslate3d 重置translate3d属性为0
// 51. trfObj 返回处理兼容后的transform对象
// 52. iScroll 使用IScroll插件创建滚动
// 53. swipe 
// 54. getPercent 根据传入的now和total算出now/total的比例，取二位小数，同时可以返回根据start、end的值计算出的当前实际值
// 55. bdMap 使用GPS或网络定位，获取当前位置信息，并返回相关信息，及创建地图
// 56. createInputDel 创建搜索框输入事件，输入时显示清除按钮，点击清除按钮清除输入数据，点击btn按钮运行函数
// 57. showMore 点击展示更多按钮，设置css('maxHeight', 'none')显示更多内容，同时隐藏展示更多按钮
// 58. toTop 插入一个返回顶部标签，需要使用类名自定义样式，点击之后实现返回顶部功能，支持iScroll和scrollTop，但暂不支持hover效果
// 59. getStar 根据传入的评分，返回一个五星评分结果的结构
// 60. preventLink 阻止a标签的默认点击事件，若有需要，提供tap事件
// 61. layerHint 使用layer的提示窗
// 62. hold 长按选择的事件
// 63. centerImg 根据相册图片高宽比，将缩略图居中显示
/************************** Ajax部分 **************************/
// 1. ajax 使用Ajax获取后台数据并填写到相应标签中，获取的后台数据是以对象形式传输
// 2. postLoadHtmlData 使用Ajax获取后台数据并填写到相应标签中，获取的后台数据是以对象形式传输
// 3. loadHtmlArrData 使用Ajax获取后台数据并填写到相应标签中，获取的后台数据是以数组形式传输
// 4. loadValEleData 使用Ajax获取后台数据并填写到相应input输入框中，获取的后台数据是以对象形式传输
// 5. loadValArrData 使用Ajax获取后台数据并填写到相应input输入框中，获取的后台数据是以数组形式传输
// 6. loadSrcData 使用Ajax获取后台数据并填写到相应input输入框中，获取的后台数据是以对象形式传输
// 7. lazyLoadingScroll 使用Ajax获取后台数据实现懒加载效果
// 8. lazyLoadingClick 使用Ajax获取后台数据实现懒加载效果
// 9. LazyLoadingScroll 使用面向对象，Ajax获取后台数据,结合animateCore库中的tabSwitch函数，实现tab切换加懒加载效果，IE中有bug
// 10. ajaxPaging 使用Ajax获取后台数据实现懒加载效果
// 11. timeBetweenHourAjax 从后台获取当前服务器的小时数，判断是否在某个范围内
// 12. inputData 将传入的添加数据对象和数据对象的属性进行对比，相同属性代表的标签中填入相应数据
// 13. preLoadPic 实现图片预加载，提供进度条计算，以及加载完成后回调
// 14. lsArr 使用本地存储，存储数组类型数据
// 15. lsDel 删除本地存储中对应的值，可选仅清空数据
// 16. include 使用get方式引入公共结构
/************************** Math部分 **************************/
// 1. decimalRound 将小数按照所指定的位数四舍五
// 2. changePercentage 将数字转换为百分比，可设定保留的小数位数
// 3. bubbleSortSmall 由小到大的冒泡排序
// 4. bubbleSortBig 由大到小的冒泡排序
// 5. isNumber 使用isNaN方法判断传入参数是否为数字
// 6. hideCenterPhoneNum 使用正则隐藏中间4位的手机号
// 7. hideCenterStr 将字符串的中间字符替代为*号，仅显示头尾两个字符
// 8. setLevelRange 根据分数在某个范围内，计算相应的等级
// 9. setLevelConstant 根据分数为某个精确值，计算相应的等级
// 10. showDifDecimal 若传入的值为0，则显示0.00；若传入的值为0-1之间，则精确到digits0to1位小数；若传入的值≥1，则显示digitsMore1位小数，返回值类型为string，因数字类型会自动省略最后的0
// 11. timeBetweenHour 判断时间是否在某个小时的范围内，是则返回true，否则返回false
// 12. findProp 根据传入的prop参数，查找obj对象中对应prop属性的值，并将其返回
// 13. isIntDecimal 判断传入的值是否为数字，包括整数和小数
// 14. getUrlData 正则获取当前页面url中str属性所对应的参数值
// 15. getHtml 正则某个标签及其中所有内容
// 16. isArray 判断是否为数组
// 17. findAttr 在传入元素中查找含有某个属性值的元素，并将元素返回
// 18. isjQuery 判断对象是否为jQuery对象
// 19. arrJudge 判断一个数组中是否所有布尔值都为true
// 20. phoneJudge 判断输入值是否是1开头的11位手机号
// 21. emptyJudge 判断值是否为空，为空则返回false
// 22. eleType 判断传入值类型为string，则通过该选择器获取标签并返回；类型为jQuery或Zepto对象，则返回其本身；类型为函数，可选返回用函数获取的标签，或返回函数本身
// 23. phpDate 根据后台传入的毫秒数，转换为js可用的date对象，并返回年、月、日、周几、小时、分钟、秒
// 24. doubleDigit 若传入数值为1位数，即小于10，则转换为两位数如01
// 25. href 根据传入的链接进行跳转
// 26. splitTimeStr 将传入的10:10的时间格式转换为[10, 10]的数组格式输出，其中的值为数字
// 27. subString 将传入的字符串按照index截取
// 28. hintHref 显示提示语之后间隔一定时间跳转页面
// 29. hintBack 显示提示语之后间隔一定时间返回上一页
// 30. back 返回上一页
// 31. decimalSize 获取元素的CSS高度或宽度属性，取数字并四舍五入
// 32. sortLetter 抽取对象中的城市和字母数据并按照字幕顺序排序
// 33. securityCodeJudge 判断输入的是否数字验证码，可指定位数，默认6位
// 34. getCookie 利用正则获取cookie的值
// 35. setCookie 存储cookie的值
// 36. uuid 生成uuid随机编码
// 37. dateDetail 根据当前时间，转换为js可用的date对象，并返回年、月、日、周几、小时、分钟、秒
// 38. vueProp 根据对象的属性名，创建Vue中使用的初始化属性，默认值为空
// 39. listJudge 分别对比传入数组的值，如果有值等于目标值，则返回true
// 40. pwJudge 判断是否为正确密码，默认字母加数字
// 41. arrToStr 将数组的值转换为字符串1,2,3形式
// 42. delEmptyArr 将数组中的空值去除
// 43. arrJudge 遍历数组的值，当值等于设定值时，返回true
// 44. strLen 获取字符串长度，英文及英文标点为1，中文字符为2
// 45. constellation 根据传入的月份和日期，判断星座
// 46. strToDateDetail 从时间字符串中提取时间，输出dateDetail
// 47. sameArr 输出一个具有相同值的数组
/************************** Form部分 **************************/
// 1. keyCodeJudgeStr 判断在文本框输入的按键是否为非字符，如果是，则返回false，否则返回true
// 2. keyCodeJudgeNum 判断在文本框输入的按键是否为数字，如果是，则返回true，否则返回false
// 3. inputPlaceholder JS模拟placeholder效果，当输入有效字符时，隐藏placeholder
// 4. inputPosIntJudge 可选择判断文本框输入的值是否为数字、数字和字符串、字符串，若为非法输入，则返回true，并可设置当非法输入时，清除非非法字符
// 5. setArrAttr 批量判断数组中元素的某个属性是否定义，如果未定义则根据事件添加属性值，可通过另一个事件清除该属性的值
// 6. copyInput 
 		// 1. 针对IE9+、FF、Chrome，使用ZeroClipboard.js插件实现将input输入框内容复制到剪切板功能，需要引入ZeroClipboard.js
 		// 2. 针对IE8-，使用window.clipboardData.setData方法调用剪切板复制
// 7. vForm 简易表单验证插件，初始化之后以数组形式传入验证正则或函数，在函数外部使用vForm.judge属性判断验证是否通过

// 常用变量
var db = {display: 'block'},
	dn = {display: 'none'},
	$body = $('body'),
	$window = $(window),
	isNumReg = /\d+/gi,		// 判断是否为数字的正则，\d表示[0-9]
	zeroReg = /^[0]{1}$/,		// 判断是否输入为0
	intReg = /^[1-9]{1}[0-9]*$/,		// 判断是否输入为＞0正整数
	numReg = /\D+/gi,		// 判断是否不为数字的正则，\D表示[^0-9]
	numStr_Reg = /\W+/gi,		// 判断是否不为数字和字母的正则，\W表示[^0-9_a-zA-Z]，包括下划线
	numStrReg = /[^a-z]+/gi,		// 判断是否不为字母的正则
	strReg = /[^a-z]+/gi,		// 判断是否不为字母的正则
	negInt = /^-[1-9]{1}[0-9]*$/,		// 判断是否输入为负整数
	negDemical = /^-[0-9]{1}[.]{1}[0-9]+$/,		// 判断是否输入为负小数，但可匹配-0.000
	decimalReg0to1 = /^[0-9]{1}[.]{1}[0-9]*$/,		// 判断是否输入为0-1的小数，但可匹配0.000
	decimalReg1p = /^[1-9]{1}[0-9]*[.]{1}[0-9]*$/,		// 判断是否输入为＞1的小数
	phoneReg = /^[1]\d{10}$/,		// 判断是否为1开头的数值，即为手机号
	capitalLetters = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'],
	lowercaseLetters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];

function createCore(winProp) {
	winProp = winProp || 'core';
	window[winProp] = {
		/************************** Animate部分 **************************/
		CustomAlert: CustomAlert,		// 面向对象实现点击之后展开背景，然后弹出窗口，点击瞬间关闭
		CustomAlertIm: CustomAlertIm,		// 面向对象实现点击之后瞬间展开背景，然后弹出窗口，点击关闭瞬间消失
		showAlert: showAlert,		// 实现点击之后瞬间展开背景，然后弹出窗口，点击确认、取消、关闭按钮弹窗消失，并支持回调函数
		Lottery: Lottery,		// 利用面向对象实现使用CSS3
		picFade: picFade,		// 使用闭包实现淡入淡出切换图片效果
		countTimeToDate: countTimeToDate,		// 实现传入目标时间之后，通过计时器实时获取服务器的当前时间，实现倒计时功能，同时将倒计时输入到指定标签中
		countDownTimeAjax: countDownTimeAjax,		// 实现传入目标时间之后，通过计时器实时获取服务器的当前时间，实现倒计时功能，同时将倒计时输入到指定标签中
		countDownTime: countDownTime,		// 实现传入目标时间之后，通过计时器实时获取本机的当前时间，实现倒计时功能，同时将倒计时输入到指定标签中
		intervalClass: intervalClass,		// 选取单数或双数的标签，为标签添加类名
		progressBar: progressBarIm,		// 与ajaxCore库结合，实现自定义进度条效果
		tabSwitch: tabSwitch,		// 使用jQuery实现tab切换
		caseStyle: caseStyle,		// 当标签的值< 0、== 0、> 0时，分别给标签设置样式
		clearHtmlData: clearHtmlData,		// 批量清空传入数组中所有标签中的内容
		clearHtmlData: clearHtmlData,		// 批量清空传入数组中所有input输入框中的内容
		countTimeCycle: countTimeCycle,		// 循环从后台获取倒计时时间开启倒计时，同时可以获取数据填入页面结构中
		addNumBtn: addNumBtn,		// 通过加减按钮实现每次进行事件操作之后，加减相应值，并提供回调
		touchScroll: touchScroll,		// 手指或鼠标移入按钮时，判断其所在的按钮位置，移动对应内容区滚动条到相应的位置显示内容
		tap: tap,		// 处理zepto和百度touchjs的tap事件在手指滑动时还会触发的bug
		preventDefault: preventDefault,		// 按照选择器选定的标签阻值默认事件
		stopPropagation: stopPropagation,		// 按照选择器选定的标签阻值冒泡
		countDownMM: countDownMM,		// 根据传入的毫秒数，实现倒计时功能
		popup: popup,		// 自定义弹窗，显示遮罩，同时可设置从上下左右是个方向弹出窗口
		pullDown: pullDown,		// 定义点击展开下拉菜单
		mobileHint: mobileHint,		// 仿APP的提示窗
		cycleHtml: cycleHtml,		//  根据传入数组的长度，循环输出结构
		ifDataClass: ifDataClass,		// 判断传入的值是否存在内容，若是则返回一个类名，即字符串
		ifArrClass: ifArrClass,		// 判断传入的值是否等于说要求的index值，若是则返回一个类名，即字符串
		attrInput: attrInput,		// 获取标签的属性并将其赋值给input
		htmlInput: htmlInput,		// 获取标签的值并将其赋值给input
		objToAjaxStr: objToAjaxStr,		// 将对象中的属性和属性值改写为适合ajax请求的字符串
		objToAjaxObj: objToAjaxObj,		// 将对象中的属性和属性值改写为适合ajax请求的对象型字符串
		getAjaxObj: getAjaxObj,		// 创建一个新对象，提取input的attr-data属性中对象的属性名作为新对象的属性名，同时获取input的值为属性值，组合成一个对象，用于赋值给$scope初始化时赋值使用
		createInput: createInput,		// 批量创建用于存储页面数据的input输入框
		bindInput: bindInput,		// 将两个选择器的输入框互相绑定
		bindAttrInput: bindAttrInput,		// 将相同index的ele中的attr属性值赋值给Input输入框
		bindAttrArrInput: bindAttrArrInput,		// 将相同index的ele中的attr属性值赋值给Input输入框
		bindHtmlInput: bindHtmlInput,		// 将相同index的ele中的html()值赋值给Input输入框
		bindHtmlArrInput: bindHtmlArrInput,		// 将相同index的ele中的html()值赋值给Input输入框
		bindValInput: bindValInput,		// 将相同index的ele中的val()值赋值给Input输入框
		bindValArrInput: bindValArrInput,		// 将相同index的ele中的val()值赋值给Input输入框
		addSelection: addSelection,		// 为一列标签添加点击事件，点击之后给定一个类名，默认active，表示被选中，并提供回调函数
		statusSwitch: statusSwitch,		// 根据传入的index值，切换标签的类名、内部元素的类名、样式、文字等
		switchBtn: switchBtn,		// 按钮点击之后右滑表示开启，并变换背景色
		muiPicker: muiPicker,		// 结合MUI插件，实现picker载入
		muiDtPicker: muiDtPicker,		// 结合MUI插件，实现DtPicker载入
		collectData: collectData,		// 收集页面中的数据并转换成字符串形式发送ajax请求
		limitTimeArr: limitTimeArr,		// 根据输入的起始和结束的小时：分钟格式的时间，生成其中每隔30分钟的数组，即起始时间为10:10，则从10:30开始输出
		contentScroll: contentScroll,		// 内容循环滚动
		swiperScroll: swiperScroll,		// 使用swiper创建内容滚动，避免iOS滚动困难
		resetTranslate3d: resetTranslate3d,		// 重置translate3d属性为0
		trfObj: trfObj,		// 返回处理兼容后的transform对象
		iScroll: iScroll,		// 使用IScroll插件创建滚动
		getPercent: getPercent,		// 根据传入的now和total算出now/total的比例，取二位小数，同时可以返回根据start、end的值计算出的当前实际值
		bdMap: bdMap,		// 使用GPS或网络定位，获取当前位置信息，并返回相关信息，及创建地图
		createInputDel: createInputDel,		// 创建搜索框输入事件，输入时显示清除按钮，点击清除按钮清除输入数据，点击btn按钮运行函数
		showMore: showMore,		// 点击展示更多按钮，设置css('maxHeight', 'none')显示更多内容，同时隐藏展示更多按钮
		toTop: toTop,		// 插入一个返回顶部标签，需要使用类名自定义样式，点击之后实现返回顶部功能，支持iScroll和scrollTop，但暂不支持hover效果
		getStar: getStar,		// 根据传入的评分，返回一个五星评分结果的结构
		preventLink: preventLink,		// 阻止a标签的默认点击事件，若有需要，提供tap事件
		layerHint: layerHint,		// 使用layer的提示窗
		hold: hold,		// 长按选择的事件
		centerImg: centerImg,		// 根据相册图片高宽比，将缩略图居中显示
		/************************** Ajax部分 **************************/
		ajax: ajax,		// 使用Ajax获取后台数据并填写到相应标签中，获取的后台数据是以对象形式传输
		postLoadHtmlData: postLoadHtmlData,		// 使用Ajax获取后台数据并填写到相应标签中，获取的后台数据是以对象形式传输
		loadHtmlArrData: loadHtmlArrData,		// 使用Ajax获取后台数据并填写到相应标签中，获取的后台数据是以数组形式传输
		loadValEleData: loadValEleData,		// 使用Ajax获取后台数据并填写到相应input输入框中，获取的后台数据是以对象形式传输
		loadValArrData: loadValArrData,		// 使用Ajax获取后台数据并填写到相应input输入框中，获取的后台数据是以数组形式传输
		loadSrcData: loadSrcData,		// 使用Ajax获取后台数据并填写到相应input输入框中，获取的后台数据是以对象形式传输
		lazyLoadingScroll: lazyLoadingScroll,		// 使用Ajax获取后台数据实现懒加载效果
		lazyLoadingClick: lazyLoadingClick,		// 使用Ajax获取后台数据实现懒加载效果
		LazyLoadingScroll: LazyLoadingScroll,		// 使用面向对象，Ajax获取后台数据,结合animateCore库中的tabSwitch函数，实现tab切换加懒加载效果
		ajaxPaging: ajaxPaging,		// ajaxPaging 使用Ajax获取后台数据实现懒加载效果
		timeBetweenHourAjax: timeBetweenHourAjax,		// 从后台获取当前服务器的小时数，判断是否在某个范围内
		inputData: inputData,		// 将传入的添加数据对象和数据对象的属性进行对比，相同属性代表的标签中填入相应数据
		preLoadPic: preLoadPic,		// 实现图片预加载，提供进度条计算，以及加载完成后回调
		ls: ls,		// 使用本地存储，存储数组类型数据
		lsDel: lsDel,		// 删除本地存储中对应的值，可选仅清空数据
		include: include,		// 使用get方式引入公共结构
		/************************** Math部分 **************************/
		decimalRound: decimalRound,		// 1. 将小数按照所指定的位数四舍五
		changePercentage: changePercentage,		// 2. 将数字转换为百分比，可设定保留的小数位数
		bubbleSortSmall: bubbleSortSmall,		// 3. 由小到大的冒泡排序
		bubbleSortBig: bubbleSortBig,		// 4. 由大到小的冒泡排序
		isNumber: isNumber,		// 5. 使用isNaN方法判断传入参数是否为数字
		hideCenterPhoneNum: hideCenterPhoneNum,		// 6. 使用正则隐藏中间4位的手机号
		hideCenterStr: hideCenterStr,		// 7. 将字符串的中间字符替代为*号，仅显示头尾两个字符
		setLevelRange: setLevelRange,		// 8. 根据分数在某个范围内，计算相应的等级
		setLevelConstant: setLevelConstant,		// 9. 根据分数为某个精确值，计算相应的等级
		showDifDecimal: showDifDecimal,		// 10. 若传入的值为0，则显示0.00；若传入的值为0-1之间，则精确到digits0to1位小数；若传入的值≥1，则显示digitsMore1位小数，返回值类型为string，因数字类型会自动省略最后的0
		timeBetweenHour: timeBetweenHour,		// 11. 判断时间是否在某个小时的范围内，是则返回true，否则返回false
		findProp: findProp,		// 12. 根据传入的prop参数，查找obj对象中对应prop属性的值，并将其返回
		isIntDecimal: isIntDecimal,		// 13. 判断传入的值是否为数字，包括整数和小数
		getUrlData: getUrlData,		// 14. 正则获取当前页面url中str属性所对应的参数值
		getHtml: getHtml,	// 15. 正则某个标签及其中所有内容
		isArr: isArr,		// 16, 判断是否为数组
		findAttr: findAttr,		// 在传入元素中查找含有某个属性值的元素，并将元素返回
		isjQuery: isjQuery,		// 判断对象是否为jQuery对象
		arrJudge: arrJudge,		// 判断一个数组中是否所有布尔值都为true
		phoneJudge: phoneJudge,		// 判断输入值是否是1开头的11位手机号
		emptyJudge: emptyJudge,		// 判断值是否为空，为空则返回false
		eleType: eleType,		// 判断传入值类型为string，则通过该选择器获取标签并返回；类型为jQuery或Zepto对象，则返回其本身；类型为函数，可选返回用函数获取的标签，或返回函数本身
		phpDate: phpDate,			//  根据后台传入的毫秒数，转换为js可用的date对象，并返回年、月、日、周几、小时、分钟、秒
		doubleDigit: doubleDigit,		// 若传入数值为1位数，即小于10，则转换为两位数如01
		href: href,		// 根据传入的链接进行跳转
		splitTimeStr: splitTimeStr,		// 将传入的10:10的时间格式转换为[10, 10]的数组格式输出，其中的值为数字
		subString: subString, 		// 将传入的字符串按照index截取
		hintHref: hintHref,		// 显示提示语之后间隔一定时间跳转页面
		hintBack: hintBack,		// 显示提示语之后间隔一定时间返回上一页
		back: back,		// 返回上一页
		decimalSize: decimalSize,		// 获取元素的高度或宽度，取数字并四舍五入
		sortLetter: sortLetter,		// 抽取对象中的城市和字母数据并按照字幕顺序排序
		securityCodeJudge: securityCodeJudge,		// 判断输入的是否数字验证码，可指定位数，默认6位
		getCookie: getCookie,		// 利用正则获取cookie的值
		setCookie: setCookie,		// 存储cookie的值
		uuid: uuid,		// 生成uuid随机编码
		dateDetail: dateDetail,		// 根据当前时间，转换为js可用的date对象，并返回年、月、日、周几、小时、分钟、秒
		vueProp: vueProp,		// 根据对象的属性名，创建Vue中使用的初始化属性，默认值为空
		listJudge: listJudge,		// 分别对比传入数组的值，如果有值等于目标值，则返回true
		pwJudge: pwJudge,		// 判断是否为正确密码，默认字母加数字
		arrToStr: arrToStr,		// 将数组的值转换为字符串1,2,3形式
		delEmptyArr: delEmptyArr,		// 将数组中的空值去除
		arrJudge: arrJudge, 		// 遍历数组的值，当值等于设定值时，返回true
		strLen: strLen,		// 获取字符串长度，英文及英文标点为1，中文字符为2
		constellation: constellation,		// 根据传入的月份和日期，判断星座
		strToDateDetail: strToDateDetail,		// 从时间字符串中提取时间，输出dateDetail
		sameArr: sameArr,		// 输出一个具有相同值的数组
		/************************** Form部分 **************************/
		keyCodeJudgeStr: keyCodeJudgeStr,		// 判断在文本框输入的按键是否为非字符，如果是，则返回false，否则返回true
		keyCodeJudgeNum: keyCodeJudgeNum,		// 判断在文本框输入的按键是否为数字，如果是，则返回true，否则返回false
		inputPlaceholder: inputPlaceholder,		// JS模拟placeholder效果，当输入有效字符时，隐藏placeholder
		inputPosIntJudge: inputPosIntJudge,		// 可选择判断文本框输入的值是否为数字、数字和字符串、字符串，若为非法输入，则返回true，并可设置当非法输入时，清除非非法字符
		setArrAttr: setArrAttr,		// 批量判断数组中元素的某个属性是否定义，如果未定义则根据事件添加属性值，可通过另一个事件清除该属性的值
		copyInput: copyInput,		// 1. 针对IE9+、FF、Chrome，使用ZeroClipboard.js插件实现将input输入框内容复制到剪切板功能，需要引入ZeroClipboard.js
 		// 2. 针对IE8-，使用window.clipboardData.setData方法调用剪切板复制
 		vForm: vForm		// 简易表单验证插件，初始化之后以数组形式传入验证正则或函数，在函数外部使用vForm.judge属性判断验证是否通过
	}

	/************************** Animate部分 **************************/
	/*
	 * 1
	 *  [CustomAlert 面向对象实现点击之后展开背景，然后弹出窗口，点击瞬间关闭]
	 * @param  {[对象]} showEle [传入的对象，其中包括展开的背景和窗口]
	 * @date 2016.05.09
	 * @auther Lee Chen
	 * @showEle
	 	// 创建弹窗传参对象
		function ShowEle() {
			this.$alertBtn = $('.wrap .img-box span');
			this.$outerBox = $('.wrap .outer-box');		// 背景遮罩的Box
			this.$innerBox = $('.wrap .outer-box .inner-box');		// 背景遮罩
			this.$alertBox = $('.wrap .big-img-box');
			this.$closeBtn = $('.wrap .big-img-box span');		// 点击关闭按钮
		}
	 * @HTML
		<!-- 遮罩父级 -->
		<div class="outer-box">
			<!-- 遮罩 -->
			<div class="inner-box">
			</div>
		</div>
		<!-- 弹窗 -->
		<div class="big-img-box">
			<img src="images/lee.png" alt="" title="">
			<!-- span就是关闭按钮 -->
			<span></span>
		</div>
	 * demo CustomAlertIm(showEle);
	 	// 实例化传参对象
		var showElem = new ShowEle;
	 	// 实例化对象
	 	var customAlertImm = new CustomAlert(showElem);
	 	// 直接调用函数
	 	customAlertImm.showAlertBox();
	 	// 点击事件调用
	 	showElem.$alertBtn.on('click', function () {
			customAlertImm.showAlertBox();
		});
	 */
	function CustomAlert() {
		this.clickJudge = true;		// 防止重复点击的变量
		this.showEle = null;		// 定义存储传入参数的对象
		this.$window = $(window);		// 定义window对象
	}
	// 定义函数用于传入需要使用的参数，需要在对象被实例化之后运行，否则弹窗无法运行
	CustomAlert.prototype.passPara = function(showEle){
		var _this = this;		// 存储this
		this.showEle = showEle;		// 存储传入的参数

		this.$window.resize(function () {		// 当窗口进行变化时，使窗口居中
			_this.resizeAlertBox();
		});

		if (this.showEle.$alertBtn) {		// 如果传入弹窗按钮，则绑定点击弹窗事件
			this.showEle.$alertBtn.on('click', function () {
				_this.showAlertBox();
			});
		}

		if (this.showEle.$closeBtn) {		// 如果传入关闭按钮，则绑定关闭窗口事件
			this.showEle.$closeBtn.on('click', function () {
				_this.resetAlertBox();
			});
		}
	};
	// 将背景全屏展开，并将对话框弹出
	CustomAlert.prototype.showAlertBox = function(){
		if (this.clickJudge) {
			var _this = this;
			var $window = $(window);
			var windowWidth = $window.width();
			var windowHeight = $window.height();
			var documentHeight = $(document).height();
			var alertBoxHeight = this.showEle.$alertBox.height();
			var alertBoxWidth = this.showEle.$alertBox.width();
			
			this.showEle.$outerBox.css({'display': 'block', 'width': windowWidth,  'marginTop': windowHeight / 2}).stop().animate({'marginTop': 0}, 500);
			this.showEle.$innerBox.css({'width': windowWidth}).stop().animate({'height': windowHeight}, 500, function () {
				_this.showEle.$alertBox.css({
					'display': 'block',
					'top': (windowHeight - alertBoxHeight) / 2,
					'left': (windowWidth - alertBoxWidth) / 2,
					'zIndex': 999999
				});
			});
			this.clickJudge = false;
		}
	};

	// 窗口改变大小后重新计算放大图片的位置
	CustomAlert.prototype.resizeAlertBox = function () {
		if (this.showEle.$outerBox.css('display') == 'block') {
			var $window = $(window);
			var windowWidth = $window.width();
			var windowHeight = $window.height();
			var documentHeight = $(document).height();
			var alertBoxHeight = this.showEle.$alertBox.height();
			var alertBoxWidth = this.showEle.$alertBox.width();

			this.showEle.$outerBox.css({'width': windowWidth});
			this.showEle.$innerBox.css({'width': windowWidth, 'height': windowHeight});
			this.showEle.$alertBox.css({
				'top': (windowHeight - alertBoxHeight) / 2,
				'left': (windowWidth - alertBoxWidth) / 2
			});
		}
	}

	// 点击关闭按钮之后，重置大图和背景
	CustomAlert.prototype.resetAlertBox = function(){
		this.showEle.$outerBox.css({'display': 'none', 'width': 0});
		this.showEle.$innerBox.css({'width': 0, 'height': 0});
		this.showEle.$alertBox.css({
			'display': 'none'
		});
		this.clickJudge = true;
	};

	/*
	 * 2
	 * [CustomAlertIm 面向对象实现点击之后瞬间展开背景，然后弹出窗口，点击关闭瞬间消失]
	 * @param  {[对象]} showEle [传入的对象，其中包括展开的背景和窗口]
	 * @date 2016.05.09
	 * @auther Lee Chen
	 * @showEle
	 	// 创建弹窗传参对象
		function ShowEle() {
			this.$alertBtn = $('.wrap .img-box span');
			this.$outerBox = $('.wrap .outer-box');		// 背景遮罩的Box
			this.$innerBox = $('.wrap .outer-box .inner-box');		// 背景遮罩
			this.$alertBox = $('.wrap .big-img-box');
			this.$closeBtn = $('.wrap .big-img-box span');		// 点击关闭按钮
		}
	 * @HTML
		<!-- 遮罩父级 -->
		<div class="outer-box">
			<!-- 遮罩 -->
			<div class="inner-box">
			</div>
		</div>
		<!-- 弹窗 -->
		<div class="big-img-box">
			<img src="images/lee.png" alt="" title="">
			<!-- span就是关闭按钮 -->
			<span></span>
		</div>
	 * demo CustomAlertIm(showEle);
	 	// 实例化传参对象
		var showElem = new ShowEle;
	 	// 实例化对象
	 	var customAlertImm = new CustomAlertIm(showElem);
	 	// 直接调用函数
	 	customAlertImm.showAlertBox();
	 	// 点击事件调用
	 	showElem.$alertBtn.on('click', function () {
			customAlertImm.showAlertBox();
		});
	 */
	function CustomAlertIm() {
		this.clickJudge = true;		// 防止重复点击的变量
		this.showEle = null;		// 定义存储传入参数的对象
		this.$window = $(window);		// 定义window对象
	}
	// 定义函数用于传入需要使用的参数，需要在对象被实例化之后运行，否则弹窗无法运行
	CustomAlertIm.prototype.passPara = function(showEle){
		var _this = this;		// 存储this
		this.showEle = showEle;		// 存储传入的参数

		this.$window.resize(function () {		// 当窗口进行变化时，使窗口居中
			_this.resizeAlertBox();
		});

		if (this.showEle.$alertBtn) {		// 如果传入弹窗按钮，则绑定点击弹窗事件
			this.showEle.$alertBtn.on('click', function () {
				_this.showAlertBox();
			});
		}

		if (this.showEle.$closeBtn) {		// 如果传入关闭按钮，则绑定关闭窗口事件
			this.showEle.$closeBtn.on('click', function () {
				_this.resetAlertBox();
			});
		}
	};
	// 将背景全屏展开，并将对话框弹出
	CustomAlertIm.prototype.showAlertBox = function(){
		if (this.clickJudge) {
			var _this = this;
			var $window = $(window);
			var windowWidth = $window.width();
			var windowHeight = $window.height();
			var documentHeight = $(document).height();
			var alertBoxHeight = this.showEle.$alertBox.height();
			var alertBoxWidth = this.showEle.$alertBox.width();
			
			this.showEle.$outerBox.css({'display': 'block', 'width': windowWidth,  'marginTop': windowHeight / 2}).stop().css({'marginTop': 0});
			this.showEle.$innerBox.css({
				'width': windowWidth,
				'height': windowHeight
			});
			this.showEle.$alertBox.css({
				'display': 'block',
				'top': (windowHeight - alertBoxHeight) / 2,
				'left': (windowWidth - alertBoxWidth) / 2,
				'zIndex': 999999
			});
			this.clickJudge = false;
		}
	};

	// 窗口改变大小后重新计算放大图片的位置
	CustomAlertIm.prototype.resizeAlertBox = function () {
		if (this.showEle.$outerBox.css('display') == 'block') {
			var $window = $(window);
			var windowWidth = $window.width();
			var windowHeight = $window.height();
			var documentHeight = $(document).height();
			var alertBoxHeight = this.showEle.$alertBox.height();
			var alertBoxWidth = this.showEle.$alertBox.width();

			this.showEle.$outerBox.css({'width': windowWidth});
			this.showEle.$innerBox.css({'width': windowWidth, 'height': windowHeight});
			this.showEle.$alertBox.css({
				'top': (windowHeight - alertBoxHeight) / 2,
				'left': (windowWidth - alertBoxWidth) / 2
			});
		}
	}

	// 点击关闭按钮之后，重置大图和背景
	CustomAlertIm.prototype.resetAlertBox = function(){
		this.showEle.$outerBox.css({'display': 'none', 'width': 0});
		this.showEle.$innerBox.css({'width': 0, 'height': 0});
		this.showEle.$alertBox.css({
			'display': 'none'
		});
		this.clickJudge = true;
	};

	/*
	 * 3
	 * [showAlert 实现点击之后瞬间展开背景，然后弹出窗口，点击确认、取消、关闭按钮弹窗消失，并支持回调函数]
	 * @param  {[对象]} alertObj [传入的对象，其中定义弹窗的参数]
	 * @date 2016.06.01
	 * @auther Lee Chen
	 * @HTML
		<!-- 遮罩 -->
		<div class="custom-alert-bac"></div>
		<!-- 弹窗 -->
		<div class="roll-out-points-bac"></div>
		CSS
		*html {
		  background-image: url(about:blank);
		  background-attachment: fixed;
		}
		.custom-alert-bac {
		  display: none;
		  position: fixed;
		  top: 0;
		  left: 0;
		  _position: absolute;
		  _top: expression(eval(document.documentElement.scrollTop));
		  background-color: #000;
		  _background: #fff;
		  opacity: 0.2;
		  filter: alpha(opacity=20);
		  z-index: 999998;
		}
		.roll-out-points-bac{
		  display: none;
		  position: fixed;
		  top: 0;
		  left: 0;
		  _position: absolute;
		  _top: expression(eval(document.documentElement.scrollTop + (document.documentElement.clientHeight - this.offsetHeight) / 2));
		  width: 400px;
		  height: 520px;
		  padding: 10px;
		  background-color: rgba(0, 0, 0, 0.1);
		  z-index: 999999;
		}
	 * demo showAlert(showEle);
	 	// 创建弹窗和关闭事件
		showAlert({ // 弹出转出窗口
			alertBac: $alertBac,
			alertEle: $rollOutAlert,
			alertBtn: $rollOutAlertBtn,
			closeBtn: $rollOutClose,
			cancelBtn: $rollOutCancel,
			confirmBtn: $rollOutSuccessConfirm,
			closeCallback: rollCloseCallback,
			confirmCallback: rollConfirmCallback,
			cancelCallback: rollConfirmCallback
		})
	 */
	function showAlert(alertObj) {
		var clickJudge = true;		// 防止重复点击的变量
		var $window = $(window);		// 定义window对象

		$window.resize(function () {		// 当窗口进行变化时，使窗口居中
			resizeAlertBox();
		});

		if (alertObj.alertBtn) {		// 如果传入弹窗按钮，则绑定点击弹窗事件
			alertObj.alertBtn.on('click', function () {
				showAlertBox();
			});
		}

		if (alertObj.closeBtn) {		// 如果传入关闭按钮，则绑定关闭窗口事件
			alertObj.closeBtn.on('click', function () {
				resetAlertBox();
				if (alertObj.closeCallback) {
					alertObj.closeCallback();
				}
			});
		}

		if (alertObj.cancelBtn) {		// 如果取消按钮存在，则绑定取消按钮事件
			alertObj.cancelBtn.on('click', function () {
				resetAlertBox();
				if (alertObj.cancelCallback) {
					alertObj.cancelCallback();
				}
			})
		}
		
		if (alertObj.confirmBtn) {		// 如果传入关闭按钮，则绑定关闭窗口事件
			alertObj.confirmBtn.on('click', function () {
				resetAlertBox();
				if (alertObj.confirmCallback) {
					alertObj.confirmCallback();
				}
			});
		}

		function showAlertBox(){
			if (clickJudge) {		// 利用布尔值避免重复点击
				var windowWidth = $window.width();
				var windowHeight = $window.height();
				var alertEleHeight = alertObj.alertEle.height();
				var alertEleWidth = alertObj.alertEle.width();

				alertObj.alertBac.css({		// 将弹窗背景设置为window的宽高
					'display': 'block',
					'width': windowWidth,
					'height': windowHeight,
					zIndex: 999998
				})
				alertObj.alertEle.css({		// 将弹窗背景设置为window的宽高
					'display': 'block',
					'top': (windowHeight - alertEleHeight) / 2,
					'left': (windowWidth - alertEleWidth) / 2,
					'zIndex': 999999
				});
				clickJudge = false;
				if (alertObj.showCallback) {
					alertObj.showCallback();
				}
			}
		}

		function resizeAlertBox() {
			if (alertObj.alertBac.css('display') == 'block') {		// 如果背景为显示状态，则实时计算背景和弹窗的宽高
				var windowWidth = $window.width();
				var windowHeight = $window.height();
				var alertEleHeight = alertObj.alertEle.height();
				var alertEleWidth = alertObj.alertEle.width();

				alertObj.alertBac.css({
					'width': windowWidth, 
					'height': windowHeight
				});
				alertObj.alertEle.css({
					'top': (windowHeight - alertEleHeight) / 2,
					'left': (windowWidth - alertEleWidth) / 2
				});
			}
		}

		function resetAlertBox() {		// 关闭时，将弹窗和遮罩隐藏
			alertObj.alertBac.css({
				'display': 'none',
				'width': 0, 
				'height': 0
			});
			alertObj.alertEle.css({
				'display': 'none'
			});
			clickJudge = true;
		}
	}

	/*
	 * 4
	 * [Lottery 利用面向对象实现使用CSS3 transform和transition实现点击后转盘抽奖的效果]
	 * @param  {[对象]} lotteryData [传入的对象，其中定义各种参数]
	 * @date 2016.05.10
	 * @auther Lee Chen
	 * @lotteryData
	 	function LotteryData() {
			this.$btn = $('.wrap .btn');		// 点击抽奖的按钮
			this.$showPrize = $('.wrap .show p strong');		// 显示中奖内容的按钮
			this.$turntable = $('.wrap .turntable');		// 转盘
			this.cycles = 10;		// 存储旋转圈数
			this.rotateTime = 5;		// 存储旋转时间
			this.loadDataUrl = 'loaddata.php';		// 存储获取数据的链接
			this.prizeSum = 10;		// 存储奖品的种类数量
		}
		var lotteryDataEle = new LotteryData();
	 * @HTML
		<!-- 转盘 -->
		<div class="turntable"></div>
		<!-- 开始抽奖按钮 -->
		<em class="btn"></em>
		<!-- 抽奖结果展示 -->
		<div class="show">
			<p>恭喜您获得了<strong></strong>等奖</p>
		</div>
	 * demo Lottery(lotteryDataEle);
	 	// 实例化对象
	 	var lottery = new Lottery(lotteryDataEle);
	 */
	function Lottery(lotteryData) {
		var _this = this;		// 保存this到变量中

		this.lotteryData = lotteryData;		// 将传参的对象存储
		this.rotateDeg = 0;		// 存储旋转角度的变量
		this.prizeNum = 0;		// 存储代表中奖内容的数值变量
		this.clickJudge = true;		// 控制按钮是否可以点击的布尔值
		this.prizeName = '';		// 存储中奖内容的变量
		this.lotteryNum = 0;		// 存储转动次数的变量
		this.prizeAcc = 360 / this.lotteryData.prizeSum;		// 计算每个商品在转盘上的角度

		this.lotteryData.$btn.on('click', function () {
			_this.lotteryStart();
		});
	}

	// 点击开始抽奖按钮之后，运行函数从后台获取抽奖结果，并实现抽奖
	Lottery.prototype.lotteryStart = function(){
		var _this = this;
		if (_this.clickJudge) {
			_this.clickJudge = false;		// 设置布尔值，使标签不可点击
			$.ajax({		// 使用post方法，从后台获取数据
				type: 'post',
				dataType: 'json',
				url: _this.lotteryData.loadDataUrl,
				success: function (data) {
					_this.prizeNum = data[0].number;		// 获取后台随机的奖项编号
					_this.prizeName = data[0].name;		// 获取后台的
					_this.lotteryNum = 10;		// 需要从后台获取转动次数
					if (_this.lotteryNum > 0) {
						_this.lotteryRotate();		// 控制转盘转动
						setTimeout(function () {		// 设置计时器，当转盘转完时运行
							_this.showPrizeName();		// 输入中奖结果标签的内容
							_this.clickJudge = true;		// 设置布尔值，切换按钮为可点击状态
						}, _this.lotteryData.rotateTime * 1000);		// 计时器调用的时间间隔为设定的旋转时间转换为毫秒
					}
				}
			});
		}
	};

	// 控制转盘旋转的函数
	Lottery.prototype.lotteryRotate = function(){
		// 计算旋转的角度，使用圈数加旋转的
		this.rotateDeg = this.lotteryData.cycles * 360 + (this.prizeNum - 1) * this.prizeAcc + (this.lotteryData.reduceDeg + Math.random() * (this.prizeAcc - this.lotteryData.reduceDeg * 2)
	) - 0.5 * this.prizeAcc;
		// 使用CSS3控制中奖旋转的角度，并使用transition控制旋转的时间，默认动画为ease
		this.lotteryData.$turntable.css({
			'-webkit-transform': 'rotate(0deg)',
			'-moz-transform': 'rotate(' + this.rotateDeg + 'deg)',
			'-ms-transform': 'rotate(' + this.rotateDeg + 'deg)',
			'-o-transform': 'rotate(' + this.rotateDeg + 'deg)',
			'transform': 'rotate(' + this.rotateDeg + 'deg)',
			'transition': 'transform ' + this.lotteryData.rotateTime + 's ease'
		});
	};

	// 为显示中奖结果的标签添加内容
	Lottery.prototype.showPrizeName = function () {
		this.lotteryData.$showPrize.html(this.prizeName);
	};

	// 抽奖完成后，重置转盘旋转角度和清空中奖结果标签的内容
	Lottery.prototype.initLottery = function(){
		this.lotteryData.$turntable.css({		// 重置旋转角度为0，并且清除transition的设置
			'-webkit-transform': 'rotate(0deg)',
			'-moz-transform': 'rotate(0deg)',
			'-ms-transform': 'rotate(0deg)',
			'-o-transform': 'rotate(0deg)',
			'transform': 'rotate(0deg)',
			'transition': ''
		});
		this.lotteryData.$showPrize.html('');		// 清空中奖结果标签
	};

	/*
	 * 5
	 * [picFade 使用闭包实现淡入淡出切换图片效果]
	 * @param  {[对象]} picEle [传入的对象，其中定义各种参数]
		picEle的创建示例
	 	function PicObj() {
			this.$pic = $('.header-outer .header .back span');		// 获取要切换的图片的标签
			this.delayTime = 250;		// 设置延迟切换的时间
			this.fadeTime = 250;		// 设置图片淡入淡出时间
		}
	 * @date 2016.05.12
	 * @auther Lee Chen
		var lotteryDataEle = new LotteryData();
	 * @HTML
		<!-- 切换图片的box -->
		<div class="back">
			<!-- 要切换的图片 -->
			<span></span>
			<span></span>
			<span></span>
			<span></span>
			<span></span>
		</div>
	 * demo Lottery(lotteryDataEle);
	 	// 将实例化对象传参后，创建一个变量存储函数
	 	var pic = picFade(new LightObj());
		// 调用函数，实现图片切换功能
		pic();
		// 如果需要停止图片切换，则
		$('.share-box h2').on('click', function () {
			pic(true);
		})
	 */
	function picFade(picEle) {
		// 将传入对象的属性转化为闭包的参数
		var $pic = picEle.$pic;		// 存储要切换的图片的标签
		var index = 0;		// 定义索引值，从0开始切换
		var len = $pic.length;		// 获取图片的数量
		var delayTime = picEle.delayTime;		//存储延迟切换的时间
		var fadeTime = picEle.fadeTime;		// 存储图片淡入淡出时间
		var fadeJudge = true;		// 定义参数，用于控制图片切换是否停止
		var timer = 0;		// 定义存储计时器的变量

		return function (judge) {
			if (judge == false) {
				fadeJudge = false;
			} else if (judge) {
				fadeJudge = true;
				arguments.callee();
			} else if (judge == undefined) {
				if (fadeJudge) {
					clearTimeout(timer);
					$pic.eq(index).fadeIn(fadeTime).siblings().fadeOut(fadeTime);		// 当前序号的图片淡入，其余图片都淡出，实际效果是控制上一张图片淡出
					index++;
					if (index == len) {		// 当图片切换到最后一张时，从第一张开始切换
						index = 0;
					}
					timer = setTimeout(arguments.callee, delayTime);		// 使用计时器控制图片切换的时间间隔，避免使用fadeToggle的回调函数，造成时间间隔错误
				}
			}
		}
	}

	/*
	 * 6
	 * [countTimeToDate 实现传入目标时间之后，通过计时器实时获取服务器的当前时间，实现倒计时功能，同时将倒计时输入到指定标签中]
	 * @param  {[对象]} countObj [传入的对象，其中定义各种参数]
	 * @date 2016.05.17
	 * @auther Lee Chen
	 * demo copyInput(copyEle);
	 	// 将对象传参后，调用
	 	countTimeToDate({
			'showEle': $countEle,		// 获取填写倒计时的标签
			'coverEle': $coverEle,		// 获取倒计时结束之后，清除的遮罩
			'endYear': 2016,		// 设定结束时间
			'endMth': 4,		// 设定结束时间
			'endDate': 20,		// 设定结束时间
			'endHour': 0,		// 设定结束时间
			'endMin': 0,		// 设定结束时间
			'endSec': 0,		// 设定结束时间
			'hour': '时',		// 写在小时时间之后的文字
			'minute': '分',		// 写在分钟时间之后的文字
			'second': '秒'		// 写在秒时间之后的文字
		});
	 */
	function countTimeToDate(countObj) {
		// 获取当前日期
		var countTimer = 0;
		function count() {
			$.ajax({
				'type': 'post',
				'dataType': 'json',
				'url': 'loaddata.php',
				'success': function (data) {
					var endDate = new Date(countObj.endYear, countObj.endMth, countObj.endDate, countObj.endHour, countObj.endMin, countObj.endSec)		// 设定结束时间
					var nowDate = new Date(data);		// 通过后台获取当前时间
					var difference = 0;
					difference = endDate.getTime() - nowDate.getTime();
					if (difference > 0) {		// 如果时间未达到指定的时间，则运行倒计时
						var diffDay = Math.floor(difference / 1000 / 60 / 60 / 24);		// 计算相差的天数
						var diffHour = Math.floor(difference / 1000 / 60 / 60 - (diffDay * 24));		// 计算相差的小时数
						var diffMin = Math.floor((difference / 1000 / 60) - (diffDay * 24 * 60) - (diffHour * 60));		// 计算相差的分钟数
						var diffSec = Math.floor((difference / 1000) - (diffDay * 24 * 60 * 60) - (diffHour * 60 * 60) - (diffMin * 60));		// 计算相差的秒数
						if (diffDay < 10) {		// 如果出现一位数，转换为两位数，同时将数据类型转为number
							diffDay = Number("0" + diffDay);
						}
						if (diffHour < 10) {		// 如果出现一位数，转换为两位数，同时将数据类型转为number
							diffHour = Number("0" + diffHour);
						}
						if (diffMin < 10) {		// 如果出现一位数，转换为两位数，同时将数据类型转为number
							diffMin = Number("0" + diffMin);
						}
						if (diffSec < 10) {		// 如果出现一位数，转换为两位数，同时将数据类型转为number
							diffSec = Number("0" + diffSec);
						}
						countObj.textEle.html(countObj.textCount);		// 为标签替换文字
						countObj.showEle.html((diffHour + diffDay * 24) + countObj.hour + diffMin + countObj.minute + diffSec + countObj.second);		// 将结果写入标签中
					} else {		// 如果时间达到指定的时间
						countObj.coverEle.css(countObj.coverCSS);
						countObj.textEle.html(countObj.textEnd);		// 为标签替换文字
						countObj.textEle.css(countObj.textCss)
						clearInterval(countTimer);		// 清除计时器，停止倒计时
					}
				}
			})
		}count();		// 直接运行一次函数，防止计时器运行后才能调用产生延迟
		countTimer = setInterval(count, 16);		//启动计时器，实时获取数据
	}

	/*
	 * 7
	 * [countDownTimeAjax 实现传入目标时间之后，通过计时器实时获取服务器的当前时间，实现倒计时功能，同时将倒计时输入到指定标签中]
	 * @param  {[对象]} countObj [传入的对象，其中定义各种参数]
	 * @date 2016.05.26
	 * @auther Lee Chen
	 * demo copyInput(copyEle);
	 	// 将对象传参后，调用
	 	countDownTimeAjax({
			showEle: $countDownRoll,		// 获取填写倒计时的标签
			loadUrl: '../inputdata.php',		// 从后台获取倒计时的URL
			textEnd: '获取验证码',		// 倒计时结束时显示的文字
			countClass: 'security-selected',		// 倒计时计算时，写入的类名
			countTime: 2000		// 设定倒计时时间
		}, function () {
			rollCountJudge = true;
			rollCountEndJudge = true;
			rollInputJudge();

			$('.roll-out-points h2 span').css({
				display: 'block'
			})
			$('.roll-out-points h2 strong').css({
				display: 'none'
			})
		});
	 */

	function countDownTimeAjax(countObj, callback) {
		var date = (new Date()).getTime() + countObj.countTime;		// 使用系统当前时间，设定一个虚拟结束时间，用于调试
		// 获取当前日期
		var countTimer = 0;
		countObj.showEle.addClass(countObj.countClass);

		function count() {
			$.ajax({
				'type': 'post',
				'dataType': 'json',
				'url': countObj.loadUrl,
				'success': function (data) {
					var endDate = new Date(date);		// 设定结束时间，需要从后台传入一个毫秒数
					var nowDate = new Date();		// 通过后台获取当前时间
					var difference = 0;
					difference = endDate.getTime() - nowDate.getTime();
					if (difference > 0) {		// 如果时间未达到指定的时间，则运行倒计时
						countObj.showEle.html(Math.ceil(difference / 1000));
					} else {		// 如果时间达到指定的时间
						countObj.showEle.html(countObj.textEnd);
						countObj.showEle.removeClass(countObj.countClass);
						if (countObj.endClass) {
							countObj.showEle.addClass(countObj.endClass);
						}
						clearInterval(countTimer);		// 清除计时器，停止倒计时
						if (callback) {
							callback();
						}
					}
				}
			})
		}count();		// 直接运行一次函数，防止计时器运行后才能调用产生延迟
		countTimer = setInterval(count, 16);		//启动计时器，实时获取数据
	}

	/*
	 * 8
	 * [countDownTime 实现传入目标时间之后，通过计时器实时获取本机的当前时间，实现倒计时功能，同时将倒计时输入到指定标签中]
	 * @param  {[对象]} countObj [传入的对象，其中定义各种参数]
	 * @date 2016.05.26
	 * @auther Lee Chen
	 * demo copyInput(copyEle);
	 	// 将对象传参后，调用
	 	countDownTime({
			showEle: $countDownRoll,		// 获取填写倒计时的标签
			textEnd: '获取验证码',		// 倒计时结束时显示的文字
			countClass: 'security-selected',		// 倒计时计算时，写入的类名
			countTime: 60000		// 设定倒计时时间
		}, function () {
			rollCountJudge = true;
		})

		clearInterval(countDownTimer);

		var count = core.countDownTime({
			// btn: 'body .wrap .store-app .store-app-box .store-app-con form section span',
			// event: 'tap',
			show: 'body .wrap .store-app .store-app-box .store-app-con form section span',
			textEnd: '发送验证码',		// 倒计时结束时显示的文字
			countTime: 6000,		// 设定倒计时时间
			click: function (_this) {
				console.log(_this.obj.show)
			},
			ajaxJudge: {
				url: function () {
					return hostUrl + 'user/sms/send?query={"mobile":"' + $phoneInput.val() + '","flag":"login"}'
				},
				judge: function (data) {
					hint.show(data.message);
					if (data.result == 1) {
						return true;
					} else {
						return false;
					}
				}
			},
			start: function () {
				console.log('start');
			},
			sec: function (sec) {
				console.log(sec);
			},
			end: function () {
				console.log('end');
			}
		});
	 */

	function countDownTime(countObj, callback) {
		function CountDown() {
			this.obj = countObj;

			this.obj.btn && this.count();
		}

		CountDown.prototype.count = function(){
			var _this = this;
			this.obj.btn = eleType(this.obj.btn);
			this.obj.show = eleType(this.obj.show) || this.obj.btn;
			this.obj.event = this.obj.event || 'click';
			this.obj.endTime = new Date((new Date()).getTime() + this.obj.countTime);		// 设定结束时间
			this.obj.timer = 0;
			this.obj.judge = true;
			this.obj.btnJudge = true;

			function count() {
				var nowTime = new Date();		// 通过后台获取当前时间
				var difference = 0;
				difference = _this.obj.endTime.getTime() - nowTime.getTime();
				var sec = Math.ceil(difference / 1000);
				if (decimalRound((difference / 1000) - sec, 2) == 0) {
					_this.obj.sec && _this.obj.sec(sec);
				}
				if (difference > 0) {		// 如果时间未达到指定的时间，则运行倒计时
					_this.obj.show && _this.obj.show.html(sec + '秒');
					_this.obj.judge = false;
				} else {		// 如果时间达到指定的时间
					if (_this.obj.show) {
						_this.obj.show.html(_this.obj.textEnd);
						_this.obj.show.removeClass(_this.obj.startClass);
						if (_this.obj.endClass) {
							_this.obj.show.addClass(_this.obj.endClass);
						}
					}
					clearInterval(_this.obj.timer);		// 清除计时器，停止倒计时
					_this.obj.end && _this.obj.end();
					_this.obj.judge = true;
				}
			}

			function btnEvent() {
				_this.obj.click && _this.obj.click(_this);

				if (_this.obj.btnJudge) {
					if (_this.obj.judge) {
						if (_this.obj.ajaxJudge) {
							if (_this.obj.startAjax && _this.obj.startAjax()) {
								_this.obj.btnJudge = false;
								$.ajax({
									url: (typeof _this.obj.ajaxJudge.url == 'function') ? _this.obj.ajaxJudge.url() : _this.obj.ajaxJudge.url,
									type: (_this.obj.ajaxJudge.type ? _this.obj.ajaxJudge.type : 'get'),
									data: (_this.obj.ajaxJudge.data ? _this.obj.ajaxJudge.data() : ''),
									success: function (data) {
										_this.obj.btnJudge = true;
										_this.obj.ajaxJudge.success && _this.obj.ajaxJudge.success(data, startCount);
									}
								});
							}
							// window.ajax.load({
							// 	url: (typeof _this.obj.ajaxJudge.url == 'function') ? _this.obj.ajaxJudge.url() : _this.obj.ajaxJudge.url,
							// 	callback: function (data) {
							// 		if (_this.obj.ajaxJudge.judge && _this.obj.ajaxJudge.judge(data)) {
							// 			startCount();
							// 		}
							// 	}
							// });
						} else if (_this.obj.startJudge && _this.obj.startJudge()) {
							startCount();
						}
					}
				}
			}

			function startCount() {
				_this.obj.endTime = new Date((new Date()).getTime() + _this.obj.countTime);		// 设定结束时间
				_this.obj.show && _this.obj.show.addClass(_this.obj.startClass);
				_this.obj.start && _this.obj.start();
				count();		// 直接运行一次函数，防止计时器运行后才能调用产生延迟
				_this.obj.timer = setInterval(count, 100);		//启动计时器，实时获取数据
			}

			if (this.obj.btn) {
				this.obj.btn.on(this.obj.event, this.obj.selector, btnEvent);
			} else {
				btnEvent();
			}
		};

		CountDown.prototype.clear = function () {
			clearInterval(this.obj.timer);
		};

		return new CountDown();
	}

	/*
	 * 9
	 * [intervalClass 选取单数或双数的标签，为标签添加类名]
	 * @param  {[对象]} changeObj [传入的对象，其中定义各种参数]
	 * @date 2016.05.26
	 * @auther Lee Chen
	 * demo 
		intervalClass({
			'changeEle': $selectionEle,
			'judge': false,
			'classN': 'brown'
		});
	 */

	function intervalClass(changeObj) {
		var len = changeObj.changeEle.length;		// 获取需要标签的个数
		for (var i = 0; i < len; i++ ) {
			if (changeObj.judge) {		// 用于判断执行changeObj.judge单数添加类名还是双数，true为单数标签，false为双数
				if (i % 2 == 0) {		// 操作单数标签
					changeObj.changeEle.eq(i).addClass(changeObj.classN);
				} 
			} else {
				if (i % 2 == 1) {		// 操作双数标签
					changeObj.changeEle.eq(i).addClass(changeObj.classN);
				}
			}
		}
	}

	/*
	 * 10
	 * [progressBar 与ajaxCore库结合，实现自定义进度条效果]
	 * @param  {[对象]} progressObj [传入的对象，其中定义函数所需的元素]
	 * @param  {[对象]} progressArr [传入的对象，其中定义从后台传入数据的相应属性]
	 * @param  {[对象]} data [后台传入的对象，使用ajax库传入，无需定义]
		var proObj = {
			'progressBox': $('.progress-box'),		// 存储进度条的父级
			'progressBar': $('.progress-box .progress-outer .progress-inner'),		// 显示进度条的元素
			'hintEle': $('.progress-box .hint')		// 进度条提示的元素
		}

		proArr = ['points_level', 'points_level_total'];		// 定义传入参数的数组，用于获取从后台传入数据的相应属性
	 * @date 2016.05.20
	 * @auther Lee Chen
	 * @HTML
		<!-- 进度条box，用于存储进度条和提示 -->
		<div class="progress-box">
			<!-- 进度条父级，用于显示总进度 -->
			<div class="progress-outer">
				<!-- 进度条，用于显示进度 -->
				<div class="progress-inner"></div>
			</div>
			<p class="hint"><span></span>积分</p>
		</div>
	 * demo 
	 	var proObj = {
			'progressBox': $('.progress-box'),		// 存储进度条的父级
			'progressBar': $('.progress-box .progress-outer .progress-inner'),		// 显示进度条的元素
			'hintEle': $('.progress-box .hint')		// 进度条提示的元素
		}

		proArr = ['points_level', 'points_level_total'];		// 定义传入参数的数组，用于获取从后台传入数据的相应属性

		loadHtmlEleData(elemObj, 'inputdata.php', progressBarIm, proObj, proArr);		// 调用函数从后台传入数据，并把显示进度条函数传入，实现进度条功能
	 */

	function progressBarIm(progressObj, progressArr, data) {
		var num = 0;
		var sum = 0;
		for (var i in data) {		// 使用for-in语句遍历后台传入的对象属性
			if (i == progressArr[0]) {
				num = data[i];
			} else if (i == progressArr[1]) {
				sum = data[i];
			}
		}
		var progressRate = decimalRound((num / sum) * 100, 2);		// 计算当前进度的比例
		progressObj.progressBar.css({		// 为进度条设置宽度
			'width': progressRate + '%'
		})
		if (progressObj.hintEle) {
			progressObj.hintEle.css({		// 计算提示指针的位置
				'left': decimalRound((progressObj.hintEle.position().left - progressObj.hintEle.outerWidth() / 2) / progressObj.progressBox.width() * 100 , 2) + progressRate + '%'
			})
		}
	}

	/*
	 * 11
	 * [tabSwitch 使用jQuery实现tab切换]
	 * @param  {[对象]} this.obj [传入的对象，其中定义tab切换的元素和类名]
	 * @param  {[函数]} switchFun [传入的函数，如果函数存在则执行，同时将选中的内容标签和选择的标题标签传入该函数]
	 * @date 2016.05.20
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	tabSwitch({
			'tabTit': $('.points-detail .points-tit span'),		// 传入tab切换标题
			'tabCon': $('.points-detail .points-con > div'),		// 传入tab切换内容
			'titClass': 'select-tit',		// 传入标题点击时加入的类名
			'conClass': 'select-con',		// 传入内容显示时加入的类名
			'tabEvent': 'click'
		}, function (index, $this) {
			
		});
	 */

	function tabSwitch(obj, afterSwitch, beforeSwitch) {
		function TabSwitch() {
			this.obj = obj;
			this.init();
		}

		TabSwitch.prototype.init = function(){
			var _this = this;
			this.obj.event = this.obj.event || 'tap';
			this.obj.titClass = this.obj.titClass || 'active';
			this.obj.conClass = this.obj.conClass || 'active';
			this.obj.tit = eleType(this.obj.tit);
			this.obj.con = eleType(this.obj.con);

			(this.obj.switchCon == undefined) && (this.obj.switchCon = true);

			(this.obj.active == undefined) && (this.obj.active = 0);

			if (this.obj.init == undefined || this.obj.init == true) {
				if (this.obj.active || this.obj.active == 0) {
					if ((typeof this.obj.active == 'number')) {
						if (this.obj.selector) {
							this.obj.tit && this.obj.tit.find(this.obj.selector).eq(this.obj.active).addClass(this.obj.titClass);
						} else {
							this.obj.tit && this.obj.tit.eq(this.obj.active).addClass(this.obj.titClass);
						}
					}
					var firstIndex = this.obj.active || 0;
					this.obj.con && this.obj.con.eq(firstIndex).addClass(this.obj.conClass);

					(((this.obj.init == undefined) || (this.obj.init == true)) && afterSwitch) && afterSwitch((this.obj.tit && this.obj.tit.eq(firstIndex)), firstIndex, (this.obj.con && this.obj.con.eq(firstIndex)), firstIndex, true);		// 执行回调函数，同时传入相应参数
				}
			}

			this.obj.tit && this.obj.tit.on(this.obj.event, this.obj.selector, function (e) {		// 根据传入的点击时间
				if (_this.obj.preventDefault) {
					e.preventDefault();
				}
				var $this = $(this);
				_this.change($this.index(), $this);
			});
		};

		TabSwitch.prototype.change = function(thisIndex, $this){
			if (this.obj.selector) {
				var $beforeTit = this.obj.tit.find('.' + this.obj.titClass);
				var beforeIndex = ($beforeTit.length ? $beforeTit.index() : 0);
				!$this && ($this = this.obj.tit.find(this.obj.selector).eq(thisIndex));
			} else {
				var $beforeTit = this.obj.tit && this.obj.tit.parent().children('.' + this.obj.titClass);
				var beforeIndex = this.obj.tit && $beforeTit.index();
				!$this && ($this = this.obj.tit.eq(thisIndex));
			}

			if (beforeSwitch) {
				beforeSwitch($this, thisIndex, (this.obj.con && this.obj.con.eq(thisIndex)), beforeIndex);
			}

			if ((this.obj.remove) && (this.obj.thisIndex == this.obj.beforeIndex) && $this.hasClass(this.obj.titClass)) {
				$this.removeClass(this.obj.titClass);
			} else {
				$this && $this.addClass(this.obj.titClass)
				$this && $this.siblings().removeClass(this.obj.titClass);		// 清除按钮和内容区类名
			}

			if (this.obj.switchCon) {
				if (this.obj.type == 'class' || this.obj.type == undefined) {
					this.obj.con && this.obj.con.eq(thisIndex).addClass(this.obj.conClass).siblings().removeClass(this.obj.conClass);		// 添加按钮和内容区的点击后类名
				} else if (this.obj.type == 'css') {
					this.obj.con && this.obj.con.eq(thisIndex).css({
						display: 'block'
					}).siblings().css(dn);
				}
			}

			afterSwitch && afterSwitch($this, thisIndex, (this.obj.con && this.obj.con.eq(thisIndex)), beforeIndex);		// 执行回调函数，同时传入相应参数
		};

		return new TabSwitch();
	}

	/*
	 * 12
	 * [caseStyle 当标签的值< 0、== 0、> 0时，分别给标签设置样式]
	 * @param  {[对象]} caseEle [传入的对象，其中定义tab切换的元素和类名]
	 * @param  {[字符串]} positiveClass [为正数时添加的类名]
	 * @param  {[字符串]} positiveClass [为0数时添加的类名]
	 * @param  {[字符串]} positiveClass [为负数时添加的类名]
	 * @date 2016.05.20
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	caseStyle($('.point-detail tbody tr td:nth-child(4), .pre-record tbody tr td:nth-child(3), .roll-out tbody tr td:nth-child(3), .income-record tbody tr td:nth-child(4)'), 'add', 'add', 'reduce')
	 */
	function caseStyle(caseEle, positiveClass, zeroClass, minusClass) {
		var num = [];
		for (var i = 0; i < caseEle.length; i++) {
			num[i] = Number(caseEle.eq(i).html());
			if (num[i] > 0) {
				caseEle.eq(i).addClass(positiveClass);
			} else if (num[i] == 0) {
				caseEle.eq(i).addClass(zeroClass);
			} else if (num[i] < 0) {
				caseEle.eq(i).addClass(minusClass);
			}
		}
	}

	/*
	 * 13
	 * [clearHtmlData 批量清空传入数组中所有标签中的内容]
	 * @param  {[数组]} eleArray [包含需要清空内容的标签]
	 * @date 2016.06.13
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	clearHtmlData([$('span'), $('strong'), $('em')]);
	 */

	function clearHtmlData(eleArray) {
		for (var i = 0; i < eleArray.length; i++) {
			eleArray[i].html('');
		}
	}

	/*
	 * 14
	 * [clearValData 批量清空传入数组中所有input输入框中的内容]
	 * @param  {[数组]} eleArray [包含需要清空内容的标签]
	 * @date 2016.06.13
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	clearValData([$('span'), $('strong'), $('em')]);
	 */

	function clearValData(eleArray) {
		for (var i = 0; i < eleArray.length; i++) {
			eleArray[i].val('');
		}
	}

	/*
	 * 15
	 * [countTimeCycle 循环从后台获取倒计时时间开启倒计时，同时可以获取数据填入页面结构中]
	 * @param  {[对象]} obj [传入的对象，其中定义各种参数]
	 * @date 2016.07.11
	 * @auther Lee Chen
	 * demo 
	 	countTimeCycle({
			url: pageDataUrl,
			inputObj: {
				cycle: {
					// 限时秒杀
					quiz_goods: {
						parentEle: $('#quizGoods'),
						eleFun: function (data) {
							return '<li class="">' + 
								'<a href="' + data.id + '">' + '<img src="' + data.image + '" />' + 
									'<p>' + data.price + '</p>' + 
								'</a>' + 
							'</li>'
						}
					}
				}
			},
			hourEle: $('#leftTime span:nth-child(1)'),
			minEle: $('#leftTime span:nth-child(3)'),
			secEle: $('#leftTime span:nth-child(5)')
		})
	 */
	function countTimeCycle(obj) {
		var difference = 0;

		function loadData() {
			$.ajax({
				'type': 'post',
				'dataType': 'json',
				'url': obj.url,
				'success': function (data){
					difference = Number(data.time);

					if (obj.inputObj) {
						inputData(obj.inputObj, data);
					}
				}
			})
		}

		// 获取当前日期
		var countTimer = 0;
		function count() {
			difference -= 0.1;
			if (difference > 0) {		// 如果时间未达到指定的时间，则运行倒计时
				var diffHour = Math.floor(difference / 60 / 60);		// 计算相差的小时数
				var diffMin = Math.floor((difference / 60) - (diffHour * 60));		// 计算相差的分钟数
				var diffSec = Math.floor(difference - (diffHour * 60 * 60) - (diffMin * 60));		// 计算相差的秒数
				if (diffHour < 10) {		// 如果出现一位数，转换为两位数，同时将数据类型转为number
					diffHour = "0" + diffHour;
				}
				if (diffMin < 10) {		// 如果出现一位数，转换为两位数，同时将数据类型转为number
					diffMin = "0" + diffMin;
				}
				if (diffSec < 10) {		// 如果出现一位数，转换为两位数，同时将数据类型转为number
					diffSec = "0" + diffSec;
				}
				obj.hourEle.html(diffHour);		// 将结果写入标签中
				obj.minEle.html(diffMin);
				obj.secEle.html(diffSec);
			} else {		// 如果时间达到指定的时间
				loadData();
				if (obj.callback) {
					obj.callback();
				}
			}
		}count();		// 直接运行一次函数，防止计时器运行后才能调用产生延迟
		countTimer = setInterval(count, 100);		//启动计时器，实时获取数据
	}

	/*
	 * 16
	 * [addNumBtn 通过加减按钮实现每次进行事件操作之后，加减相应值，并提供回调]
	 * @param  {[对象]} obj [传入的对象，其中定义相关参数]
	 * @param  {[函数]} callback [操作加减按钮之后的同一个回调]
	 * @date 2016.07.29
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	core.addNumBtn({
			minus: $('.goods-quantity .div-num .num-less'),		// 减按钮
			plus: $('.goods-quantity .div-num .num-plus'),		// 加按钮
			show: $goodsNum,		// 显示结果的标签
			event: 'click',		// 操作事件
			num: goodsNum,		// 起始值
			dif: 1,		// 每次加减的值
			min: 1,		// 最小值
			max: goodsMaxNum,		// 最大值
			hintMin: function () {		// 达到最小值的回调
				d_messages('购买数量不可小于1');
			},
			hintMax: function () {		// 达到最大值的回调
				d_messages('购买数量不可大于库存');
			}
		}, function (num) {		// 操作完成之后的回调
			attrCollect(num);
		});

		// 为全部商品列表添加加减按钮计算商品总价功能
		var $goodsCon = $('body .wrap .store .goods > .swiper-wrapper > .swiper-slide');
		core.addNumBtn({
			box: 'body .wrap .store .goods .swiper-wrapper',
			minusSelector: 'i',
			plusSelector: 'b',
			show: function ($this) {
				return $this.siblings('strong');
			},		// 显示结果的标签
			event: 'tap',		// 操作事件
			num: 0,		// 起始值
			dif: function ($this) {
				return Number($this.parents('dl').attr('min_pay_num'));
			},		// 每次加减的值
			min: 0,		// 最小值
			max: function ($this) {
				return Number($this.parents('dl').attr('storage'));
			},		// 最大值
			hintMin: function () {		// 达到最小值的回调
				hint.show('购买数量不可小于0');
			},
			hintMax: function (obj) {		// 达到最大值的回调
				if (obj.max == 0) {
					hint.show('亲，该商品已无库存了哦~');
				} else {
					hint.show('购买数量不可大于库存');
				}
			}
		}, function ($show, number) {		// 操作完成之后的回调
			
		});
	 */
	function addNumBtn(obj, callback) {
		obj.event = obj.event || 'click';
		obj.dif = obj.dif || 1;
		(typeof obj.num == 'number') ? (obj.num = obj.num || 1) : obj.num;
		obj.plus = obj.plus || obj.box;
		obj.minus = obj.minus || obj.box;

		function show($this) {
			if (obj.show) {
				if (typeof obj.show == 'function') {		// 用函数动态获取显示结果的标签，可防止多个加减按钮初始化时，无法准确找到显示标签的问题
					var $showEle = obj.show($this);
					$showEle.html(obj.num);
				} else {
					var $showEle = eleType(obj.show);
					$showEle.html(obj.num);
				}
			}

			if (callback) {
				callback($showEle, obj.num);
			}
		}

		// 数量减
		eleType(obj.minus).on(obj.event, obj.minusSelector, function () {
			var $this = $(this);

			if (obj.show) {
				if (typeof obj.show == 'function') {		// 用函数动态获取显示结果的标签，可防止多个加减按钮初始化时，无法准确找到显示标签的问题
					obj.num = Number(obj.show($this).html());
				} else {
					obj.num = Number(eleType(obj.show).html());
				}
			}

			var initialNum = obj.num,
				minNum;

			(typeof obj.dif == 'function') ? obj.num -= obj.dif($this) : obj.num -= obj.dif;
			(typeof obj.min == 'function') ? minNum = obj.min($this) : minNum = obj.min;

			if (obj.num < minNum) {
				obj.num = minNum;
				
				if (obj.hintMin) {
					obj.hintMin(obj);
				}
			}
			
			show($this, obj.num);

			if (obj.minusFun) {
				obj.minusFun($this, obj.num, initialNum);
			}
		})
		// 数量加
		eleType(obj.plus).on(obj.event, obj.plusSelector, function () {
			var $this = $(this);

			if (obj.show) {
				if (typeof obj.show == 'function') {		// 用函数动态获取显示结果的标签，可防止多个加减按钮初始化时，无法准确找到显示标签的问题
					obj.num = Number(obj.show($this).html());
				} else {
					obj.num = Number(eleType(obj.show).html());
				}
			}

			var initialNum = obj.num,
				maxNum;

			(typeof obj.dif == 'function') ? obj.num += obj.dif($this) : obj.num += obj.dif;
			// obj.num += obj.dif;
			
			(typeof obj.max == 'function') ? maxNum = obj.max($this) : maxNum = obj.max;

			if (obj.num > maxNum) {
				obj.num = maxNum;
				
				if (obj.hintMax) {
					obj.hintMax(obj);
				}
			}
			
			show($this, obj.num);

			if (obj.plusFun) {
				obj.plusFun($this, obj.num, initialNum);
			}
		})
	}

	/*
	 * 17
	 * [touchScroll 手指或鼠标移入按钮时，判断其所在的按钮位置，移动对应内容区滚动条到相应的位置显示内容]
	 * @param  {[对象]} obj [传入的对象，其中定义相关参数]
	 * @date 2016.08.23
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	// 点击字母按钮之后，按字母跳转到相应的城市区域
		core.touchScroll({
			scroll: $('body .wrap .position .con-box .city > div'),
			con: $('body .wrap .position .con-box .city .city-selection-box .city-con .city-selection .letter-city'),
			btn: $('body .wrap .position .letter-selection'),
			device: 'mobile',
			type: 'trf',
			dif: -1 * $('body .header-search').height(),
			maxTrs: $('body .wrap .position .con-box .city .city-selection-box').height() - $('body .wrap .position .con-box .city').height(),
			iScroll: cityScroll
		});
	 */
	function touchScroll(obj) {
		if (obj.device == 'mobile') {
			var startEvent = 'touchstart';
			var moveEvent = 'touchmove';
			var endEvent = 'touchend';
		} else if (obj.device == 'pc') {
			var startEvent = 'mousedown';
			var moveEvent = 'mousemove';
			var endEvent = 'mouseend';
		}
		var $btn = obj.btn.children();		// 获取单个按钮标签
		var $con = obj.con.children();		// 获取单个内容区标签
		var startTop = obj.startTop || obj.btn.position().top;		// 选中的按钮父级对于窗口的Y轴位置
		var startLeft = obj.startLeft || obj.btn.position().left;		// 选中的按钮父级对于窗口的X轴位置
		obj.maxTrs = obj.maxTrs || obj.con.height() - obj.scroll.height();
		obj.dif = obj.dif || 0;

		if (obj.btnArr == undefined) {
			var btnArr = [];
			var btnLen = $btn.length
			for (var i = 0; i <= btnLen; i++) {		// 创建数组保留每个按钮相对window的位置，数组的长度等于按钮的数量 + 1
				(i < btnLen) ? btnArr[i] = $btn.eq(i).position().top : btnArr[i] = btnArr[i - 1] + $btn.height();		// 保存每个按钮的位置位移，最后一个值为最后一个按钮的位移加上它的高度
			}
		} else {
			btnArr = obj.btnArr;
		}

		// 绑定事件，按下的时候跳转滚动条，手指移动时也跳转
		var startY,
			startX,
			moveJudge;
		obj.btn.on(startEvent, obj.btnSelector, function (event) {
			((obj.event != 'click') && (obj.event != 'tap')) && goIndex(event, $(this).index());
			if ((obj.event == 'click') || (obj.event == 'tap')) {
				startY = event.touches[0].clientY;
				startX = event.touches[0].clientX;
			}
			if ((obj.move == undefined) || (obj.move == true) || (obj.event == 'click') || (obj.event == 'tap')) {
				obj.btn.on(moveEvent, moveFun);
				moveJudge = true;
			}
		});

		obj.btn.on(endEvent, obj.btnSelector, function (event) {
			((obj.event == 'click') || (obj.event == 'tap')) && goIndex(event, $(this).index());
			obj.btn.off(moveEvent, moveFun);
		});

		function moveFun(event) {
			goIndex(event);
			(obj.event == 'click') || (obj.event == 'tap') && (((event.touches[0].clientX < 0.4 * rem) && (event.touches[0].clientY < 0.4 * rem)) ? (moveJudge = true) : (moveJudge = false));
		}

		// 当传入的值小于数组的值时，返回相应的index值，表示按下了某个按钮
		function judgeIndex(num) {
			for (var i = 0; i <= btnArr.length; i++) {
				if (btnArr[i] >= num) {
					if ((i - 1) >= 0) {
						return i - 1
					}
				}
			}
		}

		// 根据按下的按钮index值，将内容区滚动条滚动到相应位置
		function goIndex(event , index) {
			((obj.stopPropagation == undefined) || (obj.stopPropagation == true)) && event.stopPropagation();
			if (obj.device == 'mobile') {
				if ((obj.event == 'click') || (obj.event == 'tap')) {
					var clY = startY - startTop;
					var clX = startX - startLeft;
				} else {
					var clY = event.touches[0].clientY - startTop;
					var clX = event.touches[0].clientX - startLeft;
				}
			} else if (obj.device == 'pc') {
				var clY = event.clientY - startTop;
				var clX = event.clientX - startLeft;
			}

			(obj.btnSelector == undefined) && (index = judgeIndex(clY));

			if ((moveJudge == true) || (moveJudge == undefined)) {
				if (clX > 0 && clX < obj.btn.width()) {
					if (index || index == 0) {
						if (obj.type == 'trf') {
							if ($(obj.iScroll.scroller).height() > $(obj.iScroll.wrapper).height()) {
								if ($con.eq(index).position().top >= obj.maxTrs) {
									if (obj.iScroll) {
										obj.iScroll.scrollTo(0, -1 * obj.maxTrs);
									} else {
										obj.scroll.css(trfObj('translate3d(0px, -' + obj.maxTrs + 'px, 0px)'));
									}
								} else {
									if (obj.iScroll) {
										obj.iScroll.scrollTo(0, -1 * $con.eq(index).position().top + obj.dif);
									} else {
										obj.scroll.css(trfObj('translate3d(0px, -' + $con.eq(index).position().top + 'px, 0px)'));
									}
								}
							}
						} else {
							obj.scroll.scrollTop($con.eq(index).position().top);
						}
					}
				}
			}
		}
	}

	/*
	 * 18
	 * [tap 处理zepto和百度touchjs的tap事件在手指滑动时还会触发的bug]
	 * @param  {[对象]} ele [进行点击事件的元素]
	 * @param  {[字符串、函数]} selectorStr [为字符串时表示事件委托的选择器，为函数时表示回调函数]
	 * @param  {[函数、数字]} callbackFun [为函数时表示回调函数，为数字时表示用于计算页面rem的基准rem值，默认的基准rem为25px]
	 * @param  {[数字]} refNum [为数字时表示用于计算页面rem的基准rem值，默认的基准rem为25px，事件委托模式下表示当前页面实际的rem值]
	 * @param  {[数字]} actNum [为数字时表示当前页面实际的rem值]
	 * @date 2016.08.26
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	touchScroll({		// 点击字母按钮之后，按字母跳转到相应的城市区域
			scroll: $('body .wrap .position .con-box .city'),
			con: $('body .wrap .position .con-box .city .city-selection-box .city-con .city-selection .letter-city'),
			btn: $('body .wrap .position .con-box .city .city-selection-box .city-con .letter-selection'),
			device: 'mobile'
		})
	 */
	function tap(ele, selectorStr, callbackFun, refNum, actNum) {
		var startX = 0;		// 用于存储起始时的手指坐标
		var startY = 0;		// 用于存储起始时的手指坐标
		var endX = 0;		// 用于存储结束时的手指坐标
		var endY = 0;		// 用于存储结束时的手指坐标

		if (typeof selectorStr == 'function') {		// 若selectorStr为函数，则代表未启用事件委托
			var selector = '';
			var callback = selectorStr;
			var ref = callbackFun;
			var act = refNum;
		} else {		// 事件委托模式
			var selector = selectorStr;
			var callback = callbackFun;
			var ref = refNum;
			var act = actNum;
		}

		(typeof ele == 'string') ? ele = $(ele) : '';

		var ratio = (10 / ref) || 0.4;		// 由页面rem的基准rem值计算出10px在rem值下所需的比例，默认的基准rem为25px
		var actRem = rem || act;		// 当前页面实际的rem值
		var tapDis = ratio * actRem;		// 计算当前手指可滑动的距离，即滑动距离在该范围之内，会判断为是点击，否则不触发点击效果，实际计算值为10px

		ele.on('touchstart', selector, tapEvent);

		function tapEvent(event) {
			startX = event.touches[0].clientX;		// 存储起始手指坐标
			startY = event.touches[0].clientY;		// 存储起始手指坐标
			endX = event.touches[0].clientX;		// 存储手指抬起时的坐标
			endY = event.touches[0].clientY;		// 存储手指抬起时的坐标
			ele.off('touchend', selector, clicked);		// 清除事件，防止事件重复添加
			ele.on('touchend', selector, clicked);		// 添加手指抬起事件，抬起时判断起始坐标和终点坐标的差值是否在范围内，以此判断是否是tap
			ele.on('touchmove', selector, function (event) {		// 添加touchmove事件，防止tap时应手指移动造成无法判断是tap事件
				endX = event.touches[0].clientX;		// 存储手指抬起时的坐标
				endY = event.touches[0].clientY;		// 存储手指抬起时的坐标
				ele.off('touchend', selector, clicked);		// 清除事件，防止事件重复添加
				ele.on('touchend', selector, clicked);		// 添加手指抬起事件，抬起时判断起始坐标和终点坐标的差值是否在范围内，以此判断是否是点击
			})
		}

		function clicked(event) {		// 手指在X、Y轴方向移动小于10px时，判断为tap事件
			if (Math.abs(endX - startX) < tapDis) {
				if (Math.abs(endY - startY) < tapDis) {
					callback($(this));
				}
			}
		}
	}

	/*
	 * 19
	 * [preventDefault 按照选择器选定的标签阻值默认事件]
	 * @param  {[字符串]} selector [需要阻止默认事件的标签选择器]
	 * @param  {[对象]} event [需要阻止的事件]
	 * @date 2016.08.27
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	preventDefault('a', 'touchstart';)
	 */
	function preventDefault(selector, event) {
		$(selector).on(event, function (event) {
			event.preventDefault();
		})
	}

	/*
	 * 20
	 * [stopPropagation 按照选择器选定的标签阻值冒泡]
	 * @param  {[字符串]} selector [需要阻止冒泡的标签选择器]
	 * @param  {[对象]} event [需要阻止冒泡的事件]
	 * @date 2016.08.27
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	stopPropagation('a', 'touchstart';)
	 */
	function stopPropagation(selector, event) {
		$(selector).on(event, function (event) {
			event.stopPropagation();
		})
	}

	/*
	 * 21
	 * [countDownMM 根据传入的毫秒数，实现倒计时功能]
	 * @param  {[对象]} ele [需要操作的标签，该标签会以参数形式传入回调函数]
	 * @param  {[数字]} mm [开始倒计时的时间]
	 * @param  {[函数]} callback [回调函数，会传入4个参数，ele:操作的标签，mm:倒计时的毫秒数，min:倒计时的分钟数，sec:倒计时的秒数（min和sec数值在0~1之间时为字符串，其余为数字类型）]
	 * @date 2016.08.27
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	stopPropagation('a', 'touchstart';)
	 */
	function countDownMM(ele, mm, callback) {
		var timer = 0;
		timer = setInterval(function () {
			mm -= 100;
			if (mm <= 0) {
				mm = 0;
				clearInterval(timer);
			}
			var min = Math.floor(mm / 1000 / 60);
			var sec = Math.floor((mm - min * 60 * 1000) / 1000);
			min < 10 ? min = '0' + min : '';
			sec < 10 ? sec = '0' + sec : '';
			callback(ele, mm, min, sec);
		}, 100);
	}

	/*
	 * 22
	 * [popup 自定义弹窗，显示遮罩，同时可设置从上下左右是个方向弹出窗口]
	 * @param  {[对象]} obj [传入的参数]
	 * @date 2016.08.29
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	var popup = popup({
			show: '.search',		// 点击弹出按钮的选择器
			close: 'body .popup-con .search-input form span',		// 点击关闭按钮的选择器
			event: 'tap',		// 触发和关闭弹窗的事件
			direction: 0,		// 弹窗进入的方向，0~3，分别对应上右下左
			height: '10rem',		// 设置弹窗高度
			width: '10rem',		// 设置弹窗宽度
			bac: true,		// 是否点击背景可关闭弹窗
			css: {		// 给弹窗设置样式
				backgroundColor: '#faa'
			},
			class: 'show',		// 给弹窗设置类名
			html: '<div class="search-input">' + 		// 弹窗结构
					'<form>' + 
						'<span></span>' + 
						'<input type="text" name="" value="">' + 
					'</form>' + 
				'</div>' + 
				'<div class="search-con">' + 
					'<div class="search-history">' + 
						'<span>厦门大学（思明校区）</span>' + 
						'<span>厦门大学（漳州校区）</span>' + 
						'<span>厦门大学（思明校区）</span>' + 
						'<span>厦门大学（思明校区）</span>' + 
					'</div>' + 
					'<div class="search-result">' + 
						'<span>厦门大学（思明校区）</span>' + 
						'<span>厦门大学（思明校区）</span>' + 
						'<span>厦门大学（思明校区）</span>' + 
						'<span>厦门大学（思明校区）</span>' + 
					'</div>' + 
				'</div>',
		});
	 */
	var popupNum = 1;
	function popup(obj) {
		function Popup(object) {
			var _this = this;
			this.obj = object || {op: 0.6, time: 300};
			this.$body = $('body');
			this.$body.append('<div class="popup-bac" id="popupBac' + popupNum + '" style="display:none;position:fixed;left:0;right:0;top:0;bottom:0;background-color:#000;opacity:0;z-index:9999;"></div>');
			this.$body.append('<div class="popup-con" id="popupCon' + popupNum + '" style="display:none;position:fixed;left:0;top:0;width:100%;height:100%;background-color:#fff;z-index:10000;"></div>');
			this.$bac = $('#popupBac' + popupNum);
			this.$con = $('#popupCon' + popupNum);
			this.$window = $(window);
			this.winWidth = this.$window.width();
			this.winHeight = this.$window.height();

			// this.$bac.css({
			// 	display: 'none',
			// 	position: 'fixed',
			// 	left: 0,
			// 	right: 0,
			// 	top: 0,
			// 	bottom: 0,
			// 	background: '#000',
			// 	opacity: 0,
			// 	'z-index': 9999
			// });

			// this.$con.css({
			// 	display: 'none',
			// 	position: 'fixed',
			// 	top: 0,
			// 	left: 0,
			// 	width: '100%',
			// 	height: '100%',
			// 	background: '#fff',
			// 	'z-index': 10000
			// });

			this.startArr = [{		// 各个方向进入的弹窗，起始状态的数组，为保证进入前不被看到，移出屏幕较远
				left: 0,
				top: '-99999px'
			}, {
				left: '99999px',
				top: 0
			}, {
				left: 0,
				top: '99999px'
			}, {
				left: '-99999px',
				top: 0
			}];

			this.obj.html && (this.$con.append(this.obj.html));
			this.obj.event = this.obj.event || 'tap';
			this.obj.op = this.obj.op || 0.6;		// 设置默认opacity
			(this.obj.time == undefined) ? (this.obj.time = 300) : '';

			if (this.obj.height) {		// 设置默认弹窗位于页面下方
				if (this.obj.direction == 0) {
					this.startArr[this.obj.direction].top = '-' + this.obj.height + 'px'
				}
			}
			if (this.obj.width) {		// 设置默认弹窗位于页面下方
				if (this.obj.direction == 3) {
					this.startArr[this.obj.direction].left = '-' + this.obj.width
				}
			}
			if (this.obj.direction == undefined) {		// 设置默认弹窗由页面下方滑入
				this.obj.direction = 2;
			}

			this.startCSS = {		// 为弹窗设置起始位置
				'-webkit-transform': 'translate(' + _this.startArr[_this.obj.direction].left + ',' + _this.startArr[this.obj.direction].top + ')',
				'-moz-transform': 'translate(' + _this.startArr[_this.obj.direction].left + ',' + _this.startArr[this.obj.direction].top + ')',
				'-ms-transform': 'translate(' + _this.startArr[_this.obj.direction].left + ',' + _this.startArr[this.obj.direction].top + ')',
				'-o-transform': 'translate(' + _this.startArr[_this.obj.direction].left + ',' + _this.startArr[this.obj.direction].top + ')',
				'transform': 'translate(' + _this.startArr[_this.obj.direction].left + ',' + _this.startArr[this.obj.direction].top + ')',
				display: 'block'
			};

			this.$con.css(_this.startCSS);

			this.obj.addClass && this.addClass(this.obj.addClass);

			if (this.obj.show) {		// 绑定开启按钮事件
				$(this.obj.show).on(_this.obj.event, function () {
					((obj.showJudge && obj.showJudge()) || ((obj.showJudge == undefined) && true)) && _this.show($(this));
				});
			}
			if (this.obj.close) {		// 绑定关闭按钮事件
				$(this.obj.close).on(_this.obj.event, function () {
					(obj.closeJudge && obj.closeJudge() || ((obj.closeJudge == undefined) && true)) && _this.close($(this));
				});
			}
			if (this.obj.bac || this.obj.bac == undefined) {		// 
				this.$bac.on(_this.obj.event, function () {
					_this.close($(this));
				})
			}
			if (this.obj.bacStyle) {		// 设置背景样式
				this.bacStyle(this.obj.bacStyle);
			}
			if (this.obj.css) {		// 给弹窗设置样式
				this.css(this.obj.css);
			}

			if (this.obj.height) {		// 给弹窗设置高度
				this.setHeight(this.obj.height);
			}
			if (this.obj.width) {		// 给弹窗设置宽度
				this.setWidth(this.obj.width);
			}

			this.conWidth = this.$con.width();
			
			this.setPreArr();

			this.endArr = [{		// 弹窗关闭时各种状态的代码
				left: 0,
				top: 0
			}, {
				left: _this.winWidth - _this.conWidth + 'px',
				top: 0
			}, {
				left: 0,
				top: _this.winHeight - _this.conHeight + 'px'
			}, {
				left: 0,
				top: 0
			}];

			this.obj.success && this.obj.success(this.$con, this.$bac);

			popupNum++;
		}

		Popup.prototype.setPreArr = function(height){
			var _this = this;

			height && this.setHeight(height);

			this.conHeight = this.$con.height();

			this.preArr = [{		// 各个方向进入的弹窗，进入屏幕前状态的数组
				left: 0,
				top: '-' + _this.conHeight + 'px'
			}, {
				left: _this.winWidth + 'px',
				top: 0
			}, {
				left: 0,
				top: _this.winHeight + 'px'
			}, {
				left: '-' + _this.winWidth + 'px',
				top: 0
			}];
		};
		Popup.prototype.bacStyle = function(obj){		// 设置背景样式
			this.$bac.css(obj);
		};
		Popup.prototype.css = function(obj){		// 给弹窗设置样式
			this.$con.css(obj);
		};
		Popup.prototype.addClass = function(str){		// 给弹窗设置样式
			this.$con.addClass(str);
		};
		Popup.prototype.setHeight = function(str){		// 给弹窗设置高度
			this.$con.css({
				height: str
			});
		};
		Popup.prototype.setWidth = function(str){		// 给弹窗设置宽度
			this.$con.css({
				width: str
			});
		};
		Popup.prototype.show = function($this){		// 弹出弹窗
			var _this = this;
			if (_this.obj.beforeShow) {		// 弹窗前运行函数
				_this.obj.beforeShow($this, this.$con);
			}
			this.$bac.css(db).animate({		// 弹出背景
				opacity: _this.obj.op
			}, _this.obj.time);
			this.$con.css({
				'-webkit-transform': 'translate(' + _this.preArr[_this.obj.direction].left + ',' + _this.preArr[this.obj.direction].top + ')',
				'-moz-transform': 'translate(' + _this.preArr[_this.obj.direction].left + ',' + _this.preArr[this.obj.direction].top + ')',
				'-ms-transform': 'translate(' + _this.preArr[_this.obj.direction].left + ',' + _this.preArr[this.obj.direction].top + ')',
				'-o-transform': 'translate(' + _this.preArr[_this.obj.direction].left + ',' + _this.preArr[this.obj.direction].top + ')',
				'transform': 'translate(' + _this.preArr[_this.obj.direction].left + ',' + _this.preArr[this.obj.direction].top + ')'
			}).animate({		// 弹出弹窗
				'-webkit-transform': 'translate(' + _this.endArr[_this.obj.direction].left + ',' + _this.endArr[this.obj.direction].top + ')',
				'-moz-transform': 'translate(' + _this.endArr[_this.obj.direction].left + ',' + _this.endArr[this.obj.direction].top + ')',
				'-ms-transform': 'translate(' + _this.endArr[_this.obj.direction].left + ',' + _this.endArr[this.obj.direction].top + ')',
				'-o-transform': 'translate(' + _this.endArr[_this.obj.direction].left + ',' + _this.endArr[this.obj.direction].top + ')',
				'transform': 'translate(' + _this.endArr[_this.obj.direction].left + ',' + _this.endArr[this.obj.direction].top + ')'
			}, _this.obj.time, function () {
				if (_this.obj.afterShow) {		// 弹窗后运行函数
					_this.obj.afterShow($this, this.$con);
				}
			});
		};
		Popup.prototype.close = function($this){
			var _this = this;

			if (_this.obj.beforeClose) {		// 窗口关闭前运行
				_this.obj.beforeClose($this, this.$con);
			}
			this.$bac.animate({		// 关闭背景
				opacity: 0
			}, _this.obj.time, function () {
				_this.$bac.css(dn);
			});
			this.$con.animate({		// 关闭窗口
				'transform': 'translate(' + _this.preArr[_this.obj.direction].left + ',' + _this.preArr[this.obj.direction].top + ')'
			}, _this.obj.time, function () {
				_this.$con.css(_this.startCSS);
				if (_this.obj.afterClose) {		// 窗口关闭后运行
					_this.obj.afterClose($this, this.$con);
				}
			});
		};

		return new Popup(obj);
	}

	/*
	 * 23
	 * [pullDown 定义点击展开下拉菜单]
	 * @param  {[对象]} obj [传入的参数]
	 * @date 2016.08.29
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	pullDown({
			btn: 'body .wrap .confirm-order form .service header strong',		// 按钮选择器
			event: 'tap',		// 出发事件
			rotateTime: 500,		// 按钮旋转时间
			con: 'body .wrap .confirm-order form .service .input-box',		// 菜单选择器
			rotate: $('body .wrap .confirm-order form .pay-method header em'),		// 为true或undefined时，默认旋转按钮；为$('')时，判断是否jQuery或Zepto对象，并旋转该对象；为字符串时，以字符串为选择器获取标签并旋转门
			slideTime: 500,		// 菜单下拉时间
			beforeEvent: function () {		// 下拉前运行函数
				
			},
			afterEvent: function () {		// 下拉后运行函数
				
			}
		});

		// 赠送服务下拉列表
		core.pullDown({
			btn: 'body .wrap .confirm-order form .service header strong',		// 按钮选择器
			event: 'tap',		// 出发事件
			con: 'body .wrap .confirm-order form .service .input-box',		// 菜单选择器
			deg: '180deg',
			pullJudge: function () {
				return !swiper.animating;
			}
		});

		// 支付方式下拉列表
		core.pullDown({
			btn: 'body .wrap .confirm-order form .pay-method header .btn',
			event: 'tap',
			con: 'body .wrap .confirm-order form .pay-method ul',
			rotate: $('body .wrap .confirm-order form .pay-method header em'),
			pullJudge: function () {
				return !swiper.animating;
			}
		});
	 */
	function pullDown(obj) {
		obj.event = obj.event || 'click';
		obj.rotateTime = obj.rotateTime || 500;
		obj.slideTime = obj.slideTime || 500;
		var $btn = $(obj.btn);
		var isFun = (typeof obj.con == 'function');
		var $con = ((typeof obj.con == 'string') && $(obj.con)) || (isFun && obj.con);
		var $bac;
		var conHeight = obj.conHeight || (!isFun && $con.height());
		var slideJudge = true;
		var height = obj.height || 0;
		var selector = obj.selector || '';

		// 控制按钮旋转的函数
		function rotate(ele, deg) {
			if (ele == true || ele == undefined) {
				$btn.animate({
					'transform': 'rotate(' + deg + ')'
				}, obj.rotateTime);
			} else if (isjQuery(ele)) {
				ele.animate({
					'transform': 'rotate(' + deg + ')'
				}, obj.rotateTime);
			} else if (typeof ele == 'string') {
				$(ele).animate({
					'transform': 'rotate(' + deg + ')'
				}, obj.rotateTime);
			}
		}

		if (!isFun) {
			(obj.isHidden == undefined || obj.isHidden) && $con.css({
				overflow: 'hidden'
				// display: 'none',
			});
			(obj.isHeight == undefined || obj.isHeight) && $con.css({
				height: height
			});
			if ((conHeight == 0) || (conHeight != false)) {
				for (var i = 0; i < $con.children().length; i++) {
					// conHeight += Number($con.children().eq(i).css('height').split('px')[0]);
					conHeight += $con.children().eq(i).height();
				}
			}
		}

		$btn.on(obj.event, selector, pullToggle);

		function pullToggle() {
			var $this = $(this);
			if (isFun) {
				$con = obj.con($this);
				conHeight = 0;
				for (var i = 0; i < $con.children().length; i++) {
					// conHeight += Number($con.children().eq(i).css('height').split('px')[0]);
					conHeight += $con.children().eq(i).height();
				}
			}

			if (obj.pullJudge && obj.pullJudge() || ((obj.pullJudge == undefined) && true)) {
				if (obj.beforeEvent) {
					obj.beforeEvent($this, $con);
				}
				if ($con.slideToggle) {		// 如果slideToggle方法不存在，即为使用zepto时
					$con.slideToggle(obj.slideTime);
				} else {
					if (((typeof height == 'string') && ($con.css('height') == height)) || ((typeof height == 'number') && ($con.height() == height))) {
						var deg = obj.deg || '90deg';
						obj.rotate && rotate(obj.rotate, deg);
						// $con.css({
						// 	display: 'block'
						// });
						$con.animate({
							height: conHeight
						}, obj.slideTime, function () {
							slideJudge = false;
							obj.success && obj.success($this, $con);
						});
					} else {
						obj.rotate && rotate(obj.rotate, '0deg');
						$con.animate({
							height: height
						}, obj.slideTime, function () {
							slideJudge = true;
							obj.success && obj.success($this, $con);
							// $con.css({
							// 	display: 'none'
							// });
						});
					}
				}
				if (obj.afterEvent) {		// 下拉后运行
					obj.afterEvent($this, $con);
				}
			}
		}
	}

	/*
	 * 24
	 * [mobileHint 仿APP的提示窗]
	 * @param  {[对象]} obj [传入的参数]
	 * @date 2016.08.29
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		window.hint = mobileHint();		// 初始化对象，并绑定到window
		// 可自定义各种参数
	 	hint.show({
			time: 3000,		// 弹窗弹出时间
			height: '5rem',		// 弹窗的高度
			color: '#faa',		// 字体颜色
			fontSize: '2rem',		// 字体大小
			opacity: '1',		// 背景色透明度
			zIndex: 9999,		// z-index
			borderRadius: '0',		// 倒圆角
			padding: '3rem',		// padding-left和right
			bottom: '20rem',		// 由下方
			delay: 5000,		// 弹窗显示的时间
			fade: 1000,		// 弹窗淡出所需时间
			text: 'aaaaa'		// 弹窗显示文字
		});
		// 可直接传入要显示的提示内容，其余参数按照默认
		hint.show('提示语');
	 */
	function mobileHint(object) {
		function Hint() {		// 创建对象的构造函数
			this.obj = {};		// 创建obj参数用于存储传参参数
			this.timer = 0;
		}

		Hint.prototype.show = function(obj){
			var _this = this;
			clearTimeout(this.timer);
			if (this.$hint) {
				this.$hint.remove();
			}
			if ($.isPlainObject(obj)) {		// 如果传入的是对象，则使用该对象传参进行初始化
				this.init(obj)
				this.addHint();		// 添加弹窗结构
			} else if (typeof obj == 'string' || typeof obj == 'number') {		// 如果传参是字符串或数字
				this.init();		// 按照默认设定值
				this.addHint();		// 添加弹窗结构
				this.$hint.html(obj);		// 添加提示语
			}

			this.$hint.css('bottom', '-' + core.decimalRound(Number(this.$hint.css('height').split('px')[0]), 0, 0) + 'px')
			this.left();		// 为窗口设定left值
			this.$hint.animate({		// 窗口移动到终点位置上方
				bottom: _this.bottom + 0.5 + _this.unit
			}, this.obj.time, function () {
				_this.$hint.animate({		// 窗口回到重点位置，用时默认为100ms
					bottom: _this.bottom + _this.unit
				}, 100);
			});
			this.timer = setTimeout(function () {		// 利用计时器实现弹窗延时之后
				_this.close(_this);
			}, _this.obj.delay);
		};

		// 弹窗淡出并移除结构
		Hint.prototype.close = function(_this){
			_this.$hint.fadeOut(_this.obj.fade, function () {		// 弹窗淡出
				_this.$hint.remove();		// 移除结构
			})
		};

		// 为弹窗结构设定定位的left值
		Hint.prototype.left = function(){
			this.$hint.css({		// left值通过计算得到
				left: (($window.width() - this.$hint.width()) / 2) + 'px'
			})
		};

		// 将弹窗结构加入页面中，并设置相应样式
		Hint.prototype.addHint = function(){
			$body.append('<div class="mobile-hint"></div>');		// 将弹窗结构加入页面中
			this.$hint = $('body .mobile-hint');		// 获取弹窗标签
			if (this.obj.text) {		// 若初始化设定的内容存在，则添加内容
				this.$hint.html(this.obj.text);
			}

			this.$hint.css({		// 将弹窗结构初始化到需要的位置，并设定相应样式
				position: 'fixed',
				bottom: '-' + this.obj.height,
				height: this.obj.height,
				maxWidth: this.obj.maxWidth,
				padding: this.obj.padding,
				background: 'rgba(0, 0, 0, ' + this.obj.opacity + ')',
				lineHeight: this.obj.lineHeight,
				color: this.obj.color,
				fontSize: this.obj.fontSize,
				textAlign: 'center',
				zIndex: this.obj.zIndex,
				'-webkit-border-radius': this.obj.borderRadius,
				'-moz-border-radius': this.obj.borderRadius,
				'-ms-border-radius': this.obj.borderRadius,
				'-o-border-radius': this.obj.borderRadius,
				'border-radius': this.obj.borderRadius
			});
			// this.left();		// 为弹窗结构设定定位的left值
		};

		// 初始化函数，初始化设置的各种参数
		Hint.prototype.init = function(obj){
			this.obj = obj || {};		// 若未定义参数，则创建一个对象保存各种参数
			this.obj.time = this.obj.time || 100;		// 弹窗弹出时间
			this.obj.height = this.obj.height || '';		// 弹窗的高度
			this.obj.maxWidth = this.obj.maxWidth || '80%';		// 弹窗的高度
			this.obj.lineHeight = this.obj.lineHeight || '1.5rem';		// 弹窗的高度
			this.obj.color = this.obj.color || '#fff';		// 字体颜色
			this.obj.fontSize = this.obj.fontSize || '1.2rem';		// 字体大小
			this.obj.opacity = this.obj.opacity || '0.6';		// 背景色透明度
			this.obj.zIndex = this.obj.zIndex || 99999999;		// z-index
			this.obj.borderRadius = this.obj.borderRadius || '0.4rem';		// 倒圆角
			this.obj.padding = this.obj.padding || '1rem';		// padding
			this.obj.bottom = this.obj.bottom || '8rem';		// 由下方
			this.obj.delay = this.obj.delay || 2000;		// 弹窗显示的时间
			this.obj.fade = this.obj.fade || 300;		// 弹窗淡出所需时间
			this.obj.text = this.obj.text || '';		// 弹窗显示文字
			this.bottom = Number(this.obj.bottom.toString().match(/(\d+)(\D*)/)[1]);		// 通过设定的弹窗显示位置，利用正则获取其中的数字
			this.unit = this.obj.bottom.toString().match(/(\d+)(\D*)/)[2];		// 通过设定的弹窗显示位置，利用正则获取其中的单位
		};

		return new Hint();
	}

	/*
	 * 25
	 * [cycleHtml 根据传入数组的长度，循环输出结构]
	 * @param  {[数组或对象]} obj [传入的参数，数组或对象]
	 * @param  {[字符串或函数]} selector [传入的获取对象属性的选择器或生成结构的函数]
	 * @param  {[函数]} htmlFun [传入生成结构的函数]
	 * @date 2016.08.31
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		
	 */
	function cycleHtml(obj, selector, htmlFun) {
		var htmlStr = '';
		if ($.isArray(obj)) {
			for (var i = 0; i < obj.length; i++) {
				htmlStr += selector(obj[i], i);
			}
			return htmlStr;
		} else if ($.isPlainObject(obj)) {
			var arr = findProp(selector, obj);
			for (var i = 0; i < arr.length; i++) {
				htmlStr += htmlFun(arr[i], i);
			}
			return htmlStr;
		}
	}

	/*
	 * 26
	 * [ifDataClass 判断传入的值是否存在内容，若是则返回一个类名，即字符串]
	 * @param  {[字符串]} data [判断传入数据是否存在]
	 * @param  {[字符串]} className [需要返回的类名]
	 * @date 2016.08.31
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		ifDataClass(data, 'active');
	 */
	function ifDataClass(data, className) {
		if (data) {
			if (className) {
				return className;
			} else {
				return 'active';
			}
		}
	}

	/*
	 * 27
	 * [ifArrClass 判断传入的值是否等于说要求的index值，若是则返回一个类名，即字符串]
	 * @param  {[数字]} data [判断传入数据是否存在]
	 * @param  {[数字]} idnex [判断传入数据是否存在]
	 * @param  {[字符串]} className [需要返回的类名]
	 * @date 2016.08.31
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		ifArrClass(data, 1, 'active');
	 */
	function ifArrClass(data, index, className) {
		if (data == index) {
			if (className) {
				return className;
			} else {
				return 'active';
			}
		}
	}

	/*
	 * 28
	 * [attrInput 获取标签的属性并将其赋值给input]
	 * @param  {[字符串]} ele [需要获取属性的标签的选择器]
	 * @param  {[字符串]} input [需要赋值的input选择器]
	 * @param  {[字符串]} attr [需要获取属性值的属性名]
	 * @date 2016.09.01
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		attrInput('span', 'input', attr)
	 */
	function attrInput(ele, input, attr) {
		$(input).val($(ele).attr(attr));
	}

	/*
	 * 29
	 * [htmlInput 获取标签的值并将其赋值给input]
	 * @param  {[字符串]} ele [需要获取属性的标签的选择器]
	 * @param  {[字符串]} input [需要赋值的input选择器]
	 * @date 2016.09.02
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		attrInput('span', 'input', attr)
	 */
	function htmlInput(ele, input) {
		$(input).val($(ele).html());
	}

	/*
	 * 30
	 * [objToAjaxStr 将对象中的属性和属性值改写为适合ajax请求的字符串]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.01
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		objToAjaxStr(obj)
	 */
	function objToAjaxStr(obj) {
		var str = '';

		for (var i in obj) {
			str = str + '"' + i + '"' + '=' + obj[i] + '&';
		}

		str = str.substring(0, str.length-1);

		return str;
	}

	/*
	 * 31
	 * [objToAjaxObj 将对象中的属性和属性值改写为适合ajax请求的对象型字符串]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.01
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		objToAjaxObj(obj)
	 */
	function objToAjaxObj(obj) {
		var str = '{';

		for (var i in obj) {
			str = str + '"' + i + '"' + ':"' + obj[i] + '",';
		}

		str = str.substring(0, str.length-1) + '}';

		return str;
	}

	/*
	 * 32
	 * [getAjaxObj 创建一个新对象，提取input的attr-data属性中对象的属性名作为新对象的属性名，同时获取input的值为属性值，组合成一个对象，用于赋值给$scope初始化时赋值使用]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.01
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		getAjaxObj();
	 */
	function getAjaxObj() {
		var $input = $('.attr-box form input');
		var obj = {};

		for (var i = 0; i < $input.length; i++) {
			obj[$input.eq(i).attr('attr-data')] = $input.eq(i).val();
		}

		return obj
	}

	/*
	 * 33
	 * [createInput 批量创建用于存储页面数据的input输入框]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.01
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		core.createInput(['room', 'phone', 'receiver', 'recPhone', 'recAdd', 'pay', 'coupon', 'shipping', 'price']);
	 */
	function createInput(arr) {
		var htmlStr = '';
		$('body').append('<div class="attr-box"><form action=""></form></div>');
		for (var i = 0; i < arr.length; i++) {
			htmlStr += '<input type="text" name="" value="" id="' + arr[i] + '" attr-data="' + arr[i] + '">';
		}
		$('body .attr-box').css({
			position: 'fixed',
			left: '-9999px'
		})
		$('body .attr-box form').append(htmlStr);
	}

	/*
	 * 34
	 * [bindInput 将两个选择器的输入框互相绑定]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.02
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		createInput();
	 */
	function bindInput($original, $copy) {
		for (var i = 0; i < $original.length; i++) {
			$copy.eq(i).val($original.eq(i).val())
			$original.eq(i).on('input', function (num) {
				return function () {
					$copy.eq(num).val($(this).val())
				}
			}(i));
		}
	}

	/*
	 * 35
	 * [bindAttrInput 将ele中的attr属性值赋值给Input输入框]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.02
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		bindAttrInput();
	 */
	function bindAttrInput(ele, attr, input) {
		input.val(ele.attr(attr));
	}

	/*
	 * 36
	 * [bindAttrArrInput 将相同index的ele中的attr属性值赋值给Input输入框]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.02
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		bindAttrInput();
	 */
	function bindAttrArrInput(ele, attr, input) {
		for (var i = 0; i < ele.length; i++) {
			input[i].val(ele[i].attr(attr));
		}
	}

	/*
	 * 37
	 * [bindHtmlInput 将ele中的html()值赋值给Input输入框]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.02
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		bindHtmlInput();
	 */
	function bindHtmlInput(ele, input) {
		input.val(ele.html());
	}

	/*
	 * 38
	 * [bindHtmlInput 将相同index的ele中的html()值赋值给Input输入框]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.02
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		bindHtmlInput();
	 */
	function bindHtmlArrInput(ele, input) {
		for (var i = 0; i < ele.length; i++) {
			input[i].val(ele[i].html());
		}
	}

	/*
	 * 39
	 * [bindValInput 将ele中的val()值赋值给Input输入框]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.02
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		bindAttrInput();
	 */
	function bindValInput(ele, input) {
		input.val(ele.val());
	}

	/*
	 * 40
	 * [bindValArrInput 将相同index的ele中的val()值赋值给Input输入框]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.02
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		bindAttrInput();
	 */
	function bindValArrInput(ele, input) {
		for (var i = 0; i < $original.length; i++) {
			input[i].val(ele[i].val());
		}
	}

	/*
	 * 41
	 * [addSelection 为一列标签添加点击事件，点击之后给定一个类名，默认active，表示被选中，并提供回调函数]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.05
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		core.addSelection({
			ele: $('body .wrap .purchase-confirm .pay-method ul'),
			event: 'tap',
			selector: 'li',
		},
		function($this) {
			core.bindAttrInput($this, 'class', $('#pay'));
		})

		core.addSelection({
			ele: $cate,
			event: 'tap',
			parents: 'section',
			multiple: true
		},
		function($this, index) {
			if (!index) {
				$this.hasClass('active') ? $cateDetail.css(db) : $cateDetail.css(dn);
			}
		});
	 */
	function addSelection(obj, callback) {
		function AddSelection(obj, callback) {
			var _this = this;
			this.obj = obj;
			this.callback = callback;

			this.obj.event = this.obj.event || 'click';
			this.obj.className = this.obj.className || 'active';
			this.obj.selector = this.obj.selector || '';
			if (typeof this.obj.ele == 'string') {
				this.obj.ele = $(this.obj.ele);
			} else if (typeof this.obj.ele == 'function') {
				this.obj.ele = this.obj.ele();
			}

			if (this.obj.ele) {
				this.obj.ele.on(this.obj.event, this.obj.selector, function () {
					if (_this.obj.parents) {
						_this.selection($(this).parents(_this.obj.parents).index());
					} else {
						_this.selection($(this).index());
					}
					
				});
			}
		}

		AddSelection.prototype.selection = function(index){
			if (this.obj.selector) {
				var eleTmp = this.obj.ele.find(this.obj.selector);
			} else if (this.obj.parents) {
				var eleTmp = this.obj.ele.eq(index).parents(this.obj.parents);
			} else {
				var eleTmp = this.obj.ele;
			}
			if (this.obj.parents) {
				if (!eleTmp.hasClass(this.obj.className)) {
					eleTmp.addClass(this.obj.className)
					!this.obj.multiple && eleTmp.siblings().removeClass(this.obj.className);
				} else {
					this.obj.multiple && eleTmp.removeClass(this.obj.className);
				}
				if (this.callback) {
					this.callback(eleTmp, index, eleTmp.hasClass(this.obj.className));
				}
			} else {
				if (!eleTmp.eq(index).hasClass(this.obj.className)) {
					eleTmp.eq(index).addClass(this.obj.className)
					!this.obj.multiple && eleTmp.eq(index).siblings().removeClass(this.obj.className);
				} else {
					this.obj.multiple && eleTmp.eq(index).removeClass(this.obj.className);
				}
				if (this.callback) {
					this.callback(eleTmp.eq(index), index, eleTmp.eq(index).hasClass(this.obj.className));
				}
			}
		};

		return new AddSelection(obj, callback);
	}

	/*
	 * 42
	 * [statusSwitch 根据传入的index值，切换标签的类名、内部元素的类名、样式、文字等]
	 * @param  {[对象]} obj [传入初始化数据]
	 * @date 2016.09.05
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		var statusSwitch = core.statusSwitch({
			ele: $('body .wrap .order .store-box'),
			className: ['un-payed', 'un-receive', 'received', 'finished', 'canceled'],
			children: {
				status: $('body .wrap .order .store-box header strong'),
			},
			html: {
				status: ['待支付', '未接单', '已接单', '已完成', '已取消'],
			}
		});
		statusSwitch.change(0, 0);
		statusSwitch.change(1, 1);
		statusSwitch.change(2, 2);
		statusSwitch.change(3, 3);
		statusSwitch.change(4, 4);
	 */
	function statusSwitch(obj) {
		function Init(obj) {
			this.obj = obj;
		}

		Init.prototype.change = function(eleIndex, index){
			for (var i = 0; i < this.obj.className.length; i++) {		// 清除所有类名
				this.obj.ele.eq(eleIndex).removeClass(this.obj.className[i]);
			}

			this.obj.ele.eq(eleIndex).addClass(this.obj.className[index]);		// 添加选中类名
			
			for (var j in obj.children) {		// 为相应的标签添加内容
				if (typeof obj.children[j] == 'function') {		// 通过函数动态获取标签
					var eleTmp = obj.children[j](eleIndex);
					for (var i = 0; i < eleTmp.length; i++) {
						eleTmp.html(this.obj.html[j][index]);
					}
				} else {
					this.obj.children[j].eq(eleIndex).html(this.obj.html[j][index]);
				}
			}
		};

		return new Init(obj);
	}
	
	/*
	 * 43
	 * [switchBtn 按钮点击之后右滑表示开启，并变换背景色]
	 * @param  {[对象]} obj [传入初始化数据]
	 * @param  {[函数]} callback [回调函数]
	 * @date 2016.09.07
	 * @auther Lee Chen
	 * demo 
		core.switchBtn({
			btn: $('body .wrap .goods-detail .service li strong'),
			event: 'tap',
			time: 200,
			startColor: '#dddddd',
			endColor: '#00aaee'
		});
	 */
	function switchBtn(obj, callback) {
		function SwitchBtn(obj) {
			this.obj = obj;
			this.judge = [];
			this.nowLeft = [];
			this.btnWidth = [];
			this.switchTimes = [];		// 存储按钮切换次数的变量
			this.ajaxJudge = [];		// 存储用于是否进行ajax请求等判断的变量
			this.callback = callback;

			this.init(obj)
		}

		SwitchBtn.prototype.init = function(){
			var _this = this;

			this.obj.event = obj.event || 'click';
			this.obj.selector = obj.selector || '';
			this.obj.time = obj.time || 200;
			
			for (var i = 0; i < obj.btn.length; i++) {
				this.judge[i] = true;
				this.switchTimes[i] = 0;
				this.ajaxJudge[i] = true;
				this.nowLeft[i] = obj.btn.eq(i).children().position().left;
				this.btnWidth[i]= obj.btn.eq(i).width() / 2;
				this.obj.btn.eq(i).css({
					backgroundColor: this.obj.startColor
				});
				this.obj.btn.eq(i).children().css({
					left: this.nowLeft[i]
				});

				if (callback == undefined || callback) {
					this.obj.btn.eq(i).on(this.obj.event, this.obj.selector, function (num) {
						return function () {
							if ($.isPlainObject(callback)) {
								_this.btnSwitch(num, callback.callback, callback.judge);
							} else {
								_this.btnSwitch(num)
							}
						}
					}(i));
				}
			};
		}

		// 控制按钮切换的函数，可以通过judgeFun来控制在某些条件下才进行切换，thisFun为切换的回调函数
		SwitchBtn.prototype.btnSwitch = function(num, thisFun, judgeFun){
			var _this = this;
			if (this.obj.before) {
				this.obj.before(this.obj.btn.eq(num));
			}

			if (judgeFun == undefined || judgeFun) {
				if (typeof judgeFun == 'function') {
					if (judgeFun(this.obj.btn.eq(num), _this, num, this.switchTimes[num])) {
						switchFun();
					}
				} else {
					switchFun();
				}
			}
			function switchFun() {
				if (_this.judge[num]) {
					_this.obj.btn.eq(num).animate({
						backgroundColor: _this.obj.endColor
					}, obj.time);
					_this.obj.btn.eq(num).children().animate({
						left: _this.nowLeft[num] + _this.btnWidth[num]
					}, obj.time);
					_this.judge[num] = false;
				} else {
					_this.obj.btn.eq(num).animate({
						backgroundColor: _this.obj.startColor
					}, _this.obj.time);
					_this.obj.btn.eq(num).children().animate({
						left: _this.nowLeft[num]
					}, _this.obj.time);
					_this.judge[num] = true;
				}

				_this.switchTimes[num]++;

				if (thisFun) {
					thisFun(_this.obj.btn.eq(num), _this, num, _this.switchTimes[num])
				}

				if (obj.after) {
					obj.after(_this.obj.btn.eq(num), _this, num, _this.switchTimes[num]);
				}

				if (typeof _this.callback == 'function') {
					_this.callback(_this.obj.btn.eq(num), _this, num, _this.switchTimes[num]);
				}
			}
		};

		return new SwitchBtn(obj);
	}
	
	/*
	 * 44
	 * [muiPicker 结合MUI插件，实现picker载入]
	 * @param  {[对象]} obj [传入初始化数据]
	 * @date 2016.09.09
	 * @auther Lee Chen
	 * demo 
		core.switchBtn({
			btn: $('body .wrap .goods-detail .service li strong'),
			event: 'tap',
			time: 200,
			startColor: '#dddddd',
			endColor: '#00aaee'
		});
	 */
	function muiPicker(obj) {
		var selectedIndex = 0;
		var len = obj.data.length;
		var $panel;
		var $header;
		var $body;
		var $ok;
		var $cancel;
		var $bac;
		var picker;
		obj.data % 2 == 0 ? selectedIndex = len / 2 - 1 : selectedIndex = Math.floor(len / 2);
		
		function init() {
			$('body .delivery-picker .mui-poppicker-body .mui-picker .mui-picker-inner .mui-pciker-list').empty();
			$('.mui-poppicker').empty();
			// 初始化picker
			picker = new mui.PopPicker(obj.init);
			// 为picker设置数据
			picker.setData(obj.data);

			// 为panel设置样式
			$panel = $(picker.panel);
			panelCSS();

			// 为panel添加类名
			if (obj.className) {
				$panel.addClass(obj.className)
			}

			// 为header设置样式
			$header = $panel.children('.mui-poppicker-header');
			if (obj.header) {
				$header.css(obj.header);
			}

			// 为body设置样式
			$body = $(picker.body)
			if (obj.body) {
				$body.css(obj.body);
			}

			// 为ok按钮设置样式
			$ok = $(picker.ok);
			if (obj.ok) {
				$ok.css(obj.ok);
			}

			// 为cancel按钮设置样式
			$cancel = $(picker.cancel);
			if (obj.cancel) {
				$cancel.css(obj.cancel);
			}

			// 初始化默认选中选项
			for (var i = 0; i < picker.pickers.length; i++) {
				// 设置index为true或未设置时，默认选中中间值，若有设置index为数字，则显示index的值
				if (obj.index) {
					if (obj.index[i] == true || obj.index[i] == undefined) {
						picker.pickers[i].setSelectedIndex(selectedIndex, obj.setSelectedTime, obj.setSelected);
					} else if (typeof obj.index[i] == 'number') {
						picker.pickers[i].setSelectedIndex(obj.index[i], obj.setSelectedTime, obj.setSelected);
					}
				} else {
					picker.pickers[i].setSelectedIndex(selectedIndex, obj.setSelectedTime, obj.setSelected);
				}
				
				// 按设置value值初始化时选中
				if (obj.value) {
					if (obj.value[i]) {
						picker.pickers[i].setSelectedValue(obj.value[i], obj.setSelectedTime, obj.setSelected);
					}
				}
			}

			if (obj.create) {
				obj.create(picker, $panel, $header, $body, $ok, $cancel);
			}
		}init();
		
		// 关闭弹窗背景后清除

		function panelCSS() {
			if (typeof obj.panel == 'object') {
				$panel.css(obj.panel);
			} else if (typeof obj.panel == 'function') {
				obj.panel($panel);
			}
		}

		function show(selectedItem) {
			// 按下确认按钮时运行
			if (obj.confirm) {
				obj.confirm(selectedItem, picker, $panel, $header, $body, $ok, $cancel, $bac);
			}
			// 可选隐藏picker
			if (obj.hide) {
				picker.hide();
			}
			// 可选销毁picker
			if (obj.dispose) {
				picker.dispose();
			}
		}

		// 若show属性为true，直接弹出弹窗，为jQuery或Zepto对象时，绑定事件进行弹窗
		var bacJudge = true;
		if (obj.show == true || obj.show == undefined) {
			panelCSS();

			if (obj.before) {
				obj.before(picker, $panel, $header, $body, $ok, $cancel);
			}

			picker.show(show);

			if (obj.after) {
				obj.after(picker, $panel, $header, $body, $ok, $cancel);
			}
		} else if (isjQuery(obj.show)) {
			obj.event = obj.evnet || 'click';
			obj.show.off(obj.event, obj.selector, showPicker);
			obj.show.on(obj.event, obj.selector, showPicker);

		} else if (typeof obj.show == 'function') {
			obj.show().on(obj.event, obj.selector, showPicker);
		}
		function showPicker(event) {
			if (picker.disposed) {
				init();
				bacJudge = true;
			}
			panelCSS();

			if (obj.before) {
				obj.before(picker, $panel, $header, $body, $ok, $cancel);
			}

			picker.show(show);

			$bac = $('.mui-backdrop');
			if (bacJudge) {
				// 为弹窗背景设置样式
				if (obj.bac) {
					$('.mui-backdrop').css(obj.bac);
				}
				bacJudge = false;
			}

			if (obj.after) {
				obj.after(picker, $panel, $header, $body, $ok, $cancel, $bac);
			}
		}

		return picker;
	}

	/*
	 * 45
	 * [muiDtPicker 结合MUI插件，实现DtPicker载入]
	 * @param  {[对象]} obj [传入初始化数据]
	 * @date 2016.09.09
	 * @auther Lee Chen
	 * demo 
		core.switchBtn({
			btn: $('body .wrap .goods-detail .service li strong'),
			event: 'tap',
			time: 200,
			startColor: '#dddddd',
			endColor: '#00aaee'
		});
	 */
	function muiDtPicker(obj) {
		var selectedIndex = 0;
		var $panel;
		var $header;
		var $body;
		var $ok;
		var $cancel;
		var $bac;
		var $year;
		var $mon;
		var $date;
		var $hour;
		var $min;
		var picker;
		var eles;
		
		function init() {
			// 初始化picker
			picker = new mui.DtPicker(obj.init);

			// 为panel设置样式
			$panel = $(picker.ui.picker);
			panelCSS();

			// 为panel添加类名
			if (obj.className) {
				$panel.addClass(obj.className)
			}

			// 为header设置样式
			$header = $panel.children('.mui-dtpicker-header');
			if (obj.header) {
				$header.css(obj.header);
			}

			// 为body设置样式
			$body = $panel.children('.mui-dtpicker-body');
			if (obj.body) {
				$body.css(obj.body);
			}

			// 为ok按钮设置样式
			$ok = $(picker.ui.ok);
			if (obj.ok) {
				$ok.css(obj.ok);
			}

			// 为cancel按钮设置样式
			$cancel = $(picker.ui.cancel);
			if (obj.cancel) {
				$cancel.css(obj.cancel);
			}

			// 保存各个选项list
			$year = $(picker.ui.y);
			$mon = $(picker.ui.m);
			$date = $(picker.ui.d);
			$hour = $(picker.ui.h);
			$min = $(picker.ui.i);
			$bac = $('.mui-backdrop');
			eles = {
				panel: $panel, 
				header: $header, 
				body: $body, 
				ok: $ok, 
				cancel: $cancel,
				year: $year,
				mon: $mon,
				date: $date,
				hour: $hour,
				min: $min,
				bac: $bac
			};


			// 初始化默认选中选项
			// picker.getSelectedItems(obj.selected);

			if (obj.create) {
				obj.create(picker, eles);
			}
		}init();
		
		// 关闭弹窗背景后清除

		function panelCSS() {
			if (typeof obj.panel == 'object') {
				$panel.css(obj.panel);
			} else if (typeof obj.panel == 'function') {
				obj.panel($panel);
			}
		}

		function show(items) {
			// 按下确认按钮时运行
			if (obj.confirm) {
				obj.confirm(items, picker, eles);
			}
			// 可选隐藏picker
			if (obj.hide) {
				picker.hide();
			}
			// 可选销毁picker
			if (obj.dispose) {
				picker.dispose();
			}
		}

		// 若show属性为true，直接弹出弹窗，为jQuery或Zepto对象时，绑定事件进行弹窗
		var bacJudge = true;
		if (obj.show == true || obj.show == undefined) {
			panelCSS();

			if (obj.before) {
				obj.before(picker, eles);
			}

			picker.show(show);

			if (obj.after) {
				obj.after(picker, eles);
			}
		} else if (isjQuery(obj.show)) {
			obj.event = obj.evnet || 'click';
			obj.show.on(obj.event, obj.selector, function (event) {
				if (picker.disposed) {
					init();
					bacJudge = true;
				}
				panelCSS();

				if (obj.before) {
					obj.before(picker, eles);
				}

				picker.show(show);

				eles.bac = $('.mui-backdrop');
				if (bacJudge) {
					// 为弹窗背景设置样式
					if (obj.bac) {
						$('.mui-backdrop').css(obj.bac);
					}
					bacJudge = false;
				}

				if (obj.after) {
					obj.after(picker, eles);
				}
			})
		}

		return picker;
	}

	/*
	 * 46
	 * [collectData 收集页面中的数据并转换成字符串形式发送ajax请求]
	 * @param  {[对象]} obj [需要获取属性的标签的选择器]
	 * @date 2016.09.02
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
		var collect = core.collectData({
			ls: {
				data: ['user_id'],
				attr: ['customerId']
			},
			list: {
				num: {
					ele: 'body .wrap .store .goods .swiper-wrapper .swiper-slide:nth-child(1) .goods-box dl dd .goods-num strong',
					html: {
						goodscount: function ($this) {
							return $this
						}
					},
					attr: {
						goodsid: getGoods,
						is_selected: getGoods
					}
				}
			},
			ajax: {
				url: hostUrl + 'index.php?ctrl=client&action=confirmOrder&query=',
				callback: function (data) {
					console.log(data);
					if (data.result == '0') {
						hint.show(data.msg_info);
					} else {
						core.ls('orderConfirm', 'o', data);
						window.location.href = '../order/confirm.html';
					}
				}
			}
		});
	 */
	function collectData(obj) {
		function CollectData(obj) {
			this.obj = {};
			this.data = {};
			this.str = '';
			this.init(obj);
			this.dataType = obj.dataType;
			if (obj.ajax) {
				this.ajaxObj = obj.ajax;
				this.url = obj.ajax.url;
			}
		}

		CollectData.prototype.init = function(obj){
			var _this = this;

			function initData(obj, listJudge, attr) {
				if (obj.ls) {
					_this.ls(obj.ls);
				}
				
				if (obj.html) {
					_this.getEle('html', obj.html, listJudge, attr);
				}
				
				if (obj.val) {
					_this.getEle('val', obj.val, listJudge, attr);
				}

				if (obj.attr) {
					_this.getEle('attr', obj.attr, listJudge, attr);
				}
			}
			initData(obj);
			
			if (obj.select) {
				this.obj.select = {};
				for (var i in obj.select) {
					if (i != 'className') {		// 当list中的属性为html、val、attr时
						this.obj.select[i] = {};
						for (var j in obj.select[i]) {
							if (j != 'className') {
								this.data[j] = '';
								if ($.isPlainObject(obj.select[i][j])) {
									this.obj.select[i][j] = obj.select[i][j];
									this.obj.select[i][j].ele = eleType(obj.select[i][j].ele, true);
								} else {
									this.obj.select[i][j] = {};
									this.obj.select[i][j].ele = eleType(obj.select[i][j], true);
								}
								if (!this.obj.select[i][j].className) {
									if (this.obj.select.className) {
										this.obj.select[i][j].className = this.obj.select.className;
									} else {
										this.obj.select[i][j].className = 'active'
									}
								}
							}
						}
					}
				}
			}

			if (obj.list) {
				this.obj.list = {};
				for (var i in obj.list) {
					this.obj.list[i] = {};
					this.obj.list[i].ele = eleType(obj.list[i].ele, true);
					initData(obj.list[i], true, i);
				}
			}

			// console.log(this.obj)
			// console.log(this.data)
		};

		// 获取本地存储数据
		CollectData.prototype.ls = function(arr){
			this.obj.ls = arr;

			this.getLsData(arr);
		};

		CollectData.prototype.getLsData = function(arr){
			if ($.isArray(arr)) {
				for (var i = 0; i < arr.length; i++) {
					this.data[arr[i]] = ls(arr[i], 'string');
				}
			} else {
				for (var i = 0; i < arr.attr.length; i++) {
					this.data[arr.data[i]] = ls(arr.attr[i], 'string');
				}
			}
		};

		// 获取标签元素或函数，将其存入相应属性中
		CollectData.prototype.getEle = function(attr, obj, listJudge, objAttr){
			if (listJudge) {
				for (var i in obj) {
					this.data[i] = '';
					this.obj.list[objAttr][attr] = {};
					this.obj.list[objAttr][attr][i] = eleType(obj[i], true);
				}
				this.obj[attr]
			} else {
				this.obj[attr] = {};

				for (var i in obj) {
					this.data[i] = '';
					if ($.isPlainObject(obj[i])) {
						this.obj[attr][i] = obj[i];
						this.obj[attr][i].ele = eleType(obj[i].ele, true);
					} else {
						this.obj[attr][i] = eleType(obj[i], true);
					}
				}
			}
		};

		CollectData.prototype.collection = function(){
			var _this = this;

			if (this.obj.ls) {
				this.getLsData(this.obj.ls);
			}

			if (this.obj.html) {
				this.collectObjData(this.obj.html, 'html');
			}

			if (this.obj.val) {
				this.collectObjData(this.obj.val, 'val');
			}

			if (this.obj.attr) {
				this.collectObjData(this.obj.attr, 'attr');
			}

			if (this.obj.list) {
				for (var i in obj.list) {
					var eleTmp = eleType(obj.list[i].ele);
					var eleTmpLen = eleTmp.length;
					if (i.match(/num/)) {
						listData(i, function (index) {
							if (Number(eleTmp.eq(index).html()) > 0) {
								return true;
							}
						});
					} else if (i.match(/total/)) {
						listData(i);
					}
					function listData(index, listLoadJudge) {
						for (var i = 0; i < eleTmpLen; i++) {
							if (listLoadJudge == undefined) {
								collectListData(i);
							} else if (listLoadJudge) {
								if (listLoadJudge(i)) {
									collectListData(i);
								}
							}
						}
						function collectListData(eleIndex) {
							for (var i in obj.list[index]) {
								if (i != 'ele') {
									for (var j in obj.list[index][i]) {
										_this.collectEleData(obj.list[index][i][j], i, j, true, eleTmp.eq(eleIndex));
									}
								}
							}
						}
					}
				}
			}

			if (this.obj.select) {
				for (var i in this.obj.select) {
					getClassData(this.obj.select[i], i)
				}
			}

			function getClassData(obj, attr) {
				for (var i in obj) {
					eleAttr(eleType(obj[i].ele), i);
				}
				function eleAttr(ele, index) {
					for (var i = 0; i < ele.length; i++) {
						if (ele.eq(i).hasClass(obj[index].className)) {
							_this.collectEleData(ele.eq(i), attr, index);
						}
					}
				}
			}

			for (var i in this.data) {
				if (this.data[i] == undefined) {
					this.data[i] = '';
				}
			}

			return this.data;
		};

		// 收集html和val、attr Object的data
		CollectData.prototype.collectObjData = function(obj, attr){
			for (var i in obj) {
				if (i != 'className') {
					this.collectEleData(obj[i], attr, i);
				}
			}
		};

		// 收集html和val、attr的data
		CollectData.prototype.collectEleData = function(ele, attr, data, list, $this){
			var eleTmp;

			if ($.isPlainObject(ele)) {
				getEle(ele.ele);
			} else {
				getEle(ele);
			}

			if (attr == 'attr') {
				if (list) {
					this.data[data] += eleTmp.attr(data) + ',';
				} else {
					if (typeof ele.attr == 'string') {
						this.data[data] = eleTmp.attr(ele.attr);
					} else {
						this.data[data] = eleTmp.attr(data);
					}
				}
			} else {
				if (list) {
					this.data[data] += eleTmp[attr]() + ',';
				} else {
					this.data[data] = eleTmp[attr]();
				}
			}

			function getEle(ele) {
				if (typeof ele == 'function') {
					eleTmp = ele($this);
				} else {
					eleTmp = ele;
				}
			}
		};

		CollectData.prototype.dataStr = function(){
			this.collection();

			for (var i in this.data) {
				if (this.data[i][this.data[i].length - 1] == ',') {
					this.data[i] = subString(this.data[i]);
				}
			}

			if (this.dataType) {
				this.str = objToAjaxStr(this.data);
				this.clear();		// 清空data中的数据，以免重复提交造成错误
				return this.str;
			} else {
				this.str = objToAjaxObj(this.data);
				this.clear();		// 清空data中的数据，以免重复提交造成错误
				return this.str;
			}
		};

		// 清空data中的数据，以免重复提交造成错误
		CollectData.prototype.clear = function(){
			for (var i in this.data) {
				this.data[i] = '';
			}

			if (this.obj.ls) {
				this.ls(this.obj.ls);
			}
		};

		CollectData.prototype.ajax = function(){
			this.ajaxObj.url = this.url + this.dataStr();
			ajax(this.ajaxObj);
		};

		return new CollectData(obj)
	}

	/*
	 * 47
	 * [limitTimeArr 根据输入的起始和结束的小时：分钟格式的时间，生成其中每隔30分钟的数组，即起始时间为10:10，则从10:30开始输出]
	 * @param  {[字符串]} startTime [传入的字符串，其中定义获取数据的链接]
	 * @param  {[字符串]} endTime [传入的字符串，其中定义通过post传给url的数据]
	 * @param  {[字符串]} endTime [传入的字符串，其中定义通过post传给url的数据]
	 * @date 2016.09.23
	 * @auther Lee Chen
	 * demo 
		limitTimeArr('10:11', '20:00');
	 */
	function limitTimeArr(startTime, endTime, contrastTime, intervalTime) {
		var startArr = splitTimeStr(startTime),
			endArr = splitTimeStr(endTime),
			constrastArr = splitTimeStr(contrastTime) || '0:0',
			date = new Date(),
			timeTmp = [],
			msArr = [],
			timeArr = [];

		if (startArr[1] >= 30) {
			timeTmp = [startArr[0] + 1, 0];
		} else {
			timeTmp = [startArr[0], 30];
		}

		date.setSeconds(0);
		date.setMilliseconds(0);
		do{
			if (contrastTime) {
				if (timeTmp[0] > constrastArr[0] || (timeTmp[0] == constrastArr[0]) && timeTmp[1] > constrastArr[1]) {
					timeArr.push(timeTmp[0] + ':' + doubleDigit(timeTmp[1]));
					date.setHours(timeTmp[0]);
					date.setMinutes(timeTmp[1]);
					msArr.push(date.getTime().toString().substring(0, 10));
				}
			} else {
				timeArr.push(timeTmp[0] + ':' + doubleDigit(timeTmp[1]));
			}

			timeTmp[1] += 30;
			if (timeTmp[1] == 60) {
				timeTmp[1] = 0;
				timeTmp[0]++;
			}
		} while (((timeTmp[0] <= endArr[0] && timeTmp[1] < endArr[1]) || timeTmp[0] < endArr[0]));

		return [timeArr, msArr];
	}

	/*
	 * 48
	 * [contentScroll 内容循环滚动]
	 * @param  {[字符串]} startTime [传入的字符串，其中定义获取数据的链接]
	 * @param  {[字符串]} endTime [传入的字符串，其中定义通过post传给url的数据]
	 * @param  {[字符串]} endTime [传入的字符串，其中定义通过post传给url的数据]
	 * @date 2016.09.23
	 * @auther Lee Chen
	 * demo 
		limitTimeArr('10:11', '20:00');
	 */
	function contentScroll($box, time, cssJudge) {
		var $content = $box.children(),
			content = $content.html(),
			boxHeight = Number($box.css('height').split('px')[0]),
			roundHeight = decimalRound(boxHeight, 0),
			scrollData = 0;
			
		time = time || 16;
		$content.html(content + content);
		$box.height(roundHeight);
		for (var i = 0; i < $content.children().length; i++) {
			$content.children().eq(i).height(decimalRound(Number($content.children().eq(i).css('height').split('px')[0]), 0))
		}
		$content.height(decimalRound(Number($content.css('height').split('px')[0]), 0));

		if (cssJudge) {
			function cycle() {
				$content.css({
					transform: 'translateY(' + 0 + ')'
				});
				$content.animate({
					transform: 'translateY(-' + $content.height() / 2 + 'px)'
				}, time, function () {
					cycle();
				});
			}cycle();
		} else {
			if (boxHeight - roundHeight != 0) {
				setInterval(function () {
					scrollData++;
					if (scrollData >= $content.height() / 2) {
						scrollData = 0;
					}
					$box.scrollTop(scrollData);
				}, time);
			}
		}
	}

	/*
	 * 49
	 * [swiperScroll 使用swiper创建内容滚动，避免iOS滚动困难]
	 * @param  {[字符串]} selector [swiper-container的选择器]
	 * @param  {[数字]} height [需要定义的元素高度]
	 * @param  {[字符串]} endTime [在运行之前要执行的函数]
	 * @date 2016.10.12
	 * @auther Lee Chen
	 * demo 
		core.swiperScroll('body .wrap .position .con-box .school', conHeight));
	 */
	function swiperScroll(selector, height, init, before) {
		var $ele = $(selector);
		before && before($ele);
		if (height) {
			$ele.height(height);
			$ele.children().eq(0).height(height);
		}
		$ele.addClass('swiper-container').children().eq(0).addClass('swiper-wrapper').children().addClass('swiper-slide');
		$ele.find('.swiper-slide').css('height', 'auto');

		return new Swiper(selector, {
			direction: 'vertical',
			slidesPerView: 'auto',
			mousewheelControl: true,
			freeMode: true,
			onInit: function (swiper) {
				init && init(swiper);
			}
		});
	}

	/*
	 * 50
	 * [resetTranslate3d 重置translate3d属性为0]
	 * @param  {[字符串、jQuery对象]} ele [需要重置的元素]
	 * @date 2016.10.12
	 * @auther Lee Chen
	 * demo 
		core.resetTranslate3d($school.children());
	 */
	function resetTranslate3d(ele) {
		(typeof ele == 'string') && (ele = $(ele));

		ele.css({
			'-webkit-transform': 'translate3d(0px, 0px, 0px)',
			'-moz-transform': 'translate3d(0px, 0px, 0px)',
			'-ms-transform': 'translate3d(0px, 0px, 0px)',
			'-o-transform': 'translate3d(0px, 0px, 0px)',
			transform: 'translate3d(0px, 0px, 0px)'
		});
	}

	/*
	 * 51
	 * [trfObj 返回处理兼容后的transform对象]
	 * @param  {[字符串]} str [需要重置的元素]
	 * @date 2016.10.14
	 * @auther Lee Chen
	 * demo 
		trfObj('translateY(100px)');
	 */
	function trfObj(str) {
		return {
			'-webkit-transform': str,
			'-moz-transform': str,
			'-ms-transform': str,
			'-o-transform': str,
			transform: str
		};
	}

	/*
	 * 52
	 * [iScroll 使用IScroll插件创建滚动]
	 * @param  {[字符串]} str [需要重置的元素]
	 * @date 2016.10.14
	 * @auther Lee Chen
	 * demo 
		trfObj('translateY(100px)');
	 */
	function iScroll(selector, height) {
		var iScroll = {};
		height && $(selector).height(height);
		return iScroll = new IScroll(selector, {click: true, probeType: 3});
	}

	/*
	 * 53
	 * [swipe 使用IScroll插件创建滚动]
	 * @param  {[字符串]} str [需要重置的元素]
	 * @date 2016.10.14
	 * @auther Lee Chen
	 * demo 
		trfObj('translateY(100px)');
	 */
	function swipe(selector, callback) {
		function Swipe(selector) {
			
		}

		return new Swipe(selector)
	}

	/*
	 * 54
	 * [getPercent 根据传入的now和total算出now/total的比例，取二位小数，同时可以返回根据start、end的值计算出的当前实际值]
	 * @param  {[数字]} now [当前的值]
	 * @param  {[数字]} total [计算比例的总值]
	 * @param  {[数字]} end [需要重置的元素]
	 * @param  {[数字]} start [需要重置的元素]
	 * @date 2016.11.01
	 * @auther Lee Chen
	 * demo 
		trfObj('translateY(100px)');
	 */
	function getPercent(now, total, end, start) {
		(now > total) && (now = total);
		(now < 0) && (now = 0);
		var per = decimalRound(now / total, 2);

		if (end && (start == undefined)) {
			if ($.isArray(end)) {
				var result = [];
				for (var i = 0; i < end.length; i++) {
					result[i] = per * end[i];
				}
				return [per, result];
			} else {
				return [per, per * end];
			}
		} else if (end && start) {
			if ($.isArray(end) && $.isArray(start)) {
				var result = [];
				for (var i = 0; i < end.length; i++) {
					if (end[i] > start[i]) {
						result[i] = start[i] + (end[i] - start[i]) * per;
						(result[i] > end[i]) && (result[i] = end[i]);
					} else if (start[i] > end[i]) {
						result[i] = start[i] - (start[i] - end[i]) * per;
						(result[i] > start[i]) && (result[i] = start[i]);
					}
				}
				return [per, result];
			} else {
				return [per, start + (end - start) * per];
			}
		} else {
			return per;
		}
	}

	/*
	 * 55
	 * [bdMap 使用GPS或网络定位，获取当前位置信息，并返回相关信息，及创建地图]
	 * @param  {[对象]} obj [传入的参数]
	 * @date 2016.11.03
	 * @auther Lee Chen
	 * demo 
		core.bdMap({
			selector: 'allmap',
			device: 'mb',
			map: true,
			gps: function(x, y) {
				console.log(x, y)
			},
			ipDetail: function(data) {
				console.log(data)
			},
			gpsDetail: function(data) {
				console.log(data)
			},
			setMap: function(map, x, y) {
				var point = new BMap.Point(x, y);
				map.centerAndZoom(new BMap.Point(point), 15)
				map.addControl(new BMap.MapTypeControl()); //添加地图类型控件
				map.enableScrollWheelZoom(true); //开启鼠标滚轮缩放
				map.addOverlay(new BMap.Marker(point));
				map.setCenter(point);
			}
		});
	 */
	function bdMap(obj, useBaidu) {
		function Map() {
			this.obj = obj || {};
			this.map;
			this.x;
			this.y;
			this.obj.device = this.obj.device || 'mb';
			this.obj.ak = this.obj.ak || 'AiLvwp2MFrOWabjBNACtOOkpGpuGXgDU';
			// this.obj.qqAK = this.obj.qqAK || 'SWSBZ-IGR36-7V5SP-EUOEI-K3AAZ-WSFOY';
			((this.obj.init == undefined) || (this.obj.init == true)) && this.init(useBaidu);
		}

		Map.prototype.init = function(useBaidu){
			var _this = this;
			this.obj.selector && (this.map = new BMap.Map(this.obj.selector));	// 创建Map实例
			wx.getLocation({
				type: 'wgs84', // 默认为wgs84的gps坐标，如果要返回直接给openLocation用的火星坐标，可传入'gcj02'
				success: function (position) {
					wxSuccess = true;
					// alert('success');
					// alert(JSON.stringify(position));
					// alert('微信成功获取位置')
					var latitude = position.latitude; // 纬度，浮点数，范围为90 ~ -90
					var longitude = position.longitude; // 经度，浮点数，范围为180 ~ -180。
					// alert('微信');
					// alert(JSON.stringify(position));
					// var speed = position.speed; // 速度，以米/每秒计
					// var accuracy = position.accuracy; // 位置精度

					var x = position.longitude;
					var y = position.latitude;
					_this.createMap(x, y);
					_this.obj.bdGps && _this.obj.bdGps(x, y);
					_this.obj.gpsDetail && _this.gpsDetail(x, y);

					_this.obj.gps && _this.bdToGps(x, y, function (x, y) {
						_this.obj.gps && _this.obj.gps(x, y);
					});
				},
				fail: function (data) {
					// alert('fail');
					// alert(JSON.stringify(data));
					// alert('微信失败获取位置')
					baidu();
				}
			});

			if (useBaidu) {
				// alert('强制使用百度');
				baidu();
			}

			function baidu() {
				var geolocation = new BMap.Geolocation();

				geolocation.getCurrentPosition(function (position) {
					// alert('百度');
					// alert(JSON.stringify(position));
					var x = position.longitude;
					var y = position.latitude;
					_this.createMap(x, y);
					_this.obj.bdGps && _this.obj.bdGps(x, y);
					_this.obj.gpsDetail && _this.gpsDetail(x, y, undefined, 'bd09ll');

					_this.obj.gps && _this.bdToGps(x, y, function (x, y) {
						_this.obj.gps && _this.obj.gps(x, y);
					});
				}, {
					enableHighAccuracy: true,
					maximumAge: 0
				});
			}

			// alert(navigator.geolocation);
			// alert(navigator.geolocation.getCurrentPosition);
			
			// 根据GPS获取位置
			// function getGPSPosition(lng, lat) {
			// 	_this.x = lng;
			// 	_this.y = lat;
			// 	_this.obj.gps && _this.obj.gps(_this.x, _this.y);
			// 	// $('.show-result').eq(0).html(_this.x)
			// 	// $('.show-result').eq(1).html(_this.y)

			// 	// 将经纬度转成百度经纬度
			// 	_this.obj.gpsToBd && _this.gpsToBd(lng, lat, _this.obj.bdGps(x, y), _this.obj.bdData(data));
			// 	(_this.obj.bdGps || _this.obj.map) && _this.gpsToBd(lng, lat, function (x, y) {
			// 		_this.obj.bdGps && _this.obj.bdGps(x, y);
			// 		_this.obj.map && _this.createMap(x, y);
			// 	}, function (data) {
			// 		(typeof _this.obj.map == 'function') && _this.obj.map(data);
			// 	});

			// 	// 根据经纬度获取地址信息
			// 	_this.obj.gpsDetail && _this.gpsDetail(lng, lat);
			// }
			// if (navigator.geolocation) {
			// 	navigator.geolocation.getCurrentPosition(function (position) {
			// 		// alert('H5成功');
			// 		// alert(JSON.stringify(position));
			// 		// alert(JSON.stringify(position.coords));
			// 		getGPSPosition(position.coords.longitude, position.coords.latitude);
			// 	}, function (error) {
			// 		// alert('H5失败');
			// 		// alert(JSON.stringify(error));
			// 		// error && _this.netLocation();
			// 		if (error) {
			// 			var geolocation = new BMap.Geolocation();
			// 			geolocation.getCurrentPosition(function (position) {
			// 				// alert(JSON.stringify(position));
			// 				var x = position.longitude;
			// 				var y = position.latitude;
			// 				_this.createMap(x, y);
			// 				_this.obj.bdGps && _this.obj.bdGps(x, y);
			// 				_this.obj.gpsDetail && _this.gpsDetail(x, y);

			// 				_this.obj.gps && _this.bdToGps(x, y, function (x, y) {
			// 					_this.obj.gps && _this.obj.gps(x, y);
			// 				});
			// 			}, {
			// 				enableHighAccuracy: true,
			// 				maximumAge: 0
			// 			});
			// 			// var geolocation = new qq.maps.Geolocation(_this.obj.qqAK, 'leeApp');
			// 			// geolocation.getLocation(function (position) {
			// 			// 	alert('qq定位成功');
			// 			// 	console.log(position)
			// 			// 	getGPSPosition(position.lng, position.lat);
			// 			// }, function () {
			// 			// 	_this.netLocation();
			// 			// });
			// 		}
			// 	});
			// } else {
			// 	this.netLocation();
			// }
		};

		Map.prototype.gpsDetail = function(x, y, callback, type){
			var _this = this;
			$.ajax({
				// url: 'http://api.map.baidu.com/geocoder/v2/?location=' + x + ',' + y + '&ak=' + _this.obj.ak + '&coordtype=wgs84ll&pois=0&output=json',
				url: 'https://api.map.baidu.com/geocoder/v2/?location=' + y + ',' + x + '&ak=' + _this.obj.ak + '&coordtype=' + (type ? type : 'wgs84ll') + '&pois=0&output=json',
				type: 'get',
				dataType: 'jsonp',
				jsonp: 'callback',
				success: function (data) {
					_this.obj.gpsDetail && _this.obj.gpsDetail(data);
					callback && callback(data);
				}
			});
		};

		// 将经纬度转成百度经纬度
		Map.prototype.gpsToBd = function(x, y, callbackXY, callback) {
			var _this = this;
			$.ajax({
				// url: 'http://api.map.baidu.com/geoconv/v1/?coords=' + x + ',' + y + '&from=1&to=5&ak=' + _this.obj.ak,
				url: 'https://api.map.baidu.com/geoconv/v1/?coords=' + x + ',' + y + '&from=1&to=5&ak=' + _this.obj.ak,
				type: 'get',
				dataType: 'jsonp',
				jsonp: 'callback',
				success: function (data) {
					callbackXY && callbackXY(data.result[0].x, data.result[0].y)
					callback && callback(data);
				}
			});
		};

		// 将百度经纬度近似转换为GPS经纬度
		Map.prototype.bdToGps = function(x, y, callback) {
			var _this = this;
			$.ajax({
				// url: 'http://api.map.baidu.com/geoconv/v1/?coords=' + x + ',' + y + '&from=1&to=5&ak=' + _this.obj.ak,
				url: 'https://api.map.baidu.com/geoconv/v1/?coords=' + x + ',' + y + '&from=1&to=5&ak=' + _this.obj.ak,
				type: 'get',
				dataType: 'jsonp',
				jsonp: 'callback',
				success: function (data) {
					_this.x = 2 * x - data.result[0].x;
					_this.y = 2 * y - data.result[0].y;
					callback && callback(_this.x, _this.y);
				}
			});
		};

		// 根据ip地址获取地址信息
		Map.prototype.netLocation = function(callback){
			var _this = this;
			$.ajax({
				// url: 'http://api.map.baidu.com/highacciploc/v1?qterm=' + _this.obj.device + '&ak=' + _this.obj.ak + '&coord=bd09ll&callback_type=jsonp',
				// url: 'https://api.map.baidu.com/highacciploc/v1?qterm=' + _this.obj.device + '&ak=' + _this.obj.ak + '&coord=bd09ll&callback_type=jsonp',
				// url: 'https://api.map.baidu.com/location/ip?ak=' + _this.obj.ak + '&coor=bd09ll',
				url: 'http://api.map.baidu.com/location/ip?ak=' + _this.obj.ak + '&coor=bd09ll',
				type: 'get',
				dataType: 'jsonp',
				jsonp: 'callback',
				success: function (data) {
					// 高精度IP定位
					// var x = data.content.location.lng,
						// y = data.content.location.lat;
					// 普通精度IP定位
					var x = data.content.point.x,
						y = data.content.point.y;
					_this.createMap(x, y);
					_this.obj.bdGps && _this.obj.bdGps(x, y);
					_this.obj.gpsDetail && _this.gpsDetail(x, y);

					_this.obj.gps && _this.bdToGps(x, y, function (x, y) {
						_this.obj.gps && _this.obj.gps(x, y);
					});
					callback && callback(x, y);
				}
			});
		};

		// 用来创建地图的函数
		Map.prototype.createMap = function(x, y){
			if (this.obj.selector) {
				// 百度地图API功能
				// this.map = new BMap.Map(this.obj.selector);	// 创建Map实例
				
				this.obj.setMap && this.obj.setMap(this.map, x, y);
			}
		};

		return new Map();
	}

	/*
	 * 56
	 * [createInputDel 创建搜索框输入事件，输入时显示清除按钮，点击清除按钮清除输入数据，点击btn按钮运行函数]
	 * @param  {[对象]} obj [传入的参数]
	 * @date 2016.11.04
	 * @auther Lee Chen
	 * demo 
		
	 */
	function createInputDel(obj) {
		// 输入框输入内容后运行
		var $input = eleType(obj.input),
			$del = eleType(obj.del),
			$btn = eleType(obj.btn);
		obj.event = obj.event || 'click';

		$input && $input.on('input', function() {
			var $this = $(this),
				thisVal = $this.val();

			showDel(thisVal);

			obj.afterInput && obj.afterInput(thisVal, $this, $del);
		});

		$input && $input.on('focus', function() {
			var $this = $(this),
				thisVal = $this.val();

			showDel(thisVal);

			obj.afterfocus && obj.afterfocus(thisVal, $this, $del);
		});

		$input && $input.on('blur', function() {
			var $this = $(this),
				thisVal = $this.val();

			showDel(thisVal);

			obj.afterBlur && obj.afterBlur(thisVal, $this, $del);
		});

		function showDel(val) {
			if ($del) {
				if (val) {
					$del.css(db);
				} else {
					$del.css(dn);
				}
			}
		}

		// 清空输入框内容
		$del && $del.on(obj.event, function() {
			$input.val('');
			$del.css(dn);
			obj.afterDel && obj.afterDel($input, $del);
		});

		// 点击搜索按钮
		$btn && $btn.on(obj.event, function() {
			obj.afterBtn && obj.afterBtn($input.val(), $btn, $input, $del);
		});
	}

	/*
	 * 57
	 * [showMore 点击展示更多按钮，设置css('maxHeight', 'none')显示更多内容，同时隐藏展示更多按钮]
	 * @param  {[对象]} obj [传入的参数]
	 * @date 2016.11.04
	 * @auther Lee Chen
	 * demo 
		
	 */
	function showMore(ele, selector, target, callback) {
		$(ele).on('tap', selector, function () {
			var $this = $(this);
			$this.css(dn);
			if (typeof target == 'function') {
				target($this).css('maxHeight', 'none');
			} else {
				$(target).css('maxHeight', 'none');
			}
			callback && callback($this);
		});
	}

	/*
	 * 58
	 * [toTop 插入一个返回顶部标签，需要使用类名自定义样式，点击之后实现返回顶部功能，支持iScroll和scrollTop，但暂不支持hover效果]
	 * @param  {[对象]} obj [传入的参数]
	 * @date 2016.11.04
	 * @auther Lee Chen
	 * demo 
		
	 */
	function toTop(obj) {
		function ToTop(obj) {
			var _this = this;
			$('body').append('<div class="to-top">');
			this.obj = obj;
			this.obj.btn = $('body .to-top');
			this.obj.window = $(window);
			this.obj.winHeight = this.obj.window.height();
			this.obj.scrollJudge = false;
			!this.obj.time && (this.obj.time = 300);
			!this.obj.event && (this.obj.event = 'tap');

			this.init();
		}

		ToTop.prototype.init = function(){
			var _this = this;
			if (this.obj.type == 'iScroll') {
				this.obj.iScroll.on('scrollStart', function () {
					_this.obj.scrollJudge = true;
				});

				this.obj.iScroll.on('scroll', function () {
					_this.onScroll(_this.obj.iScroll);
					// _this.obj.onScroll && _this.obj.onScroll(_this.obj.iScroll);
				});

				this.obj.iScroll.on('scrollEnd', function () {
					_this.obj.scrollJudge = false;
				});

				this.obj.btn.on('tap', function () {
					_this.top(_this.obj.iScroll);
				});
			} else if (this.obj.type == 'window') {
				
			}
		};

		ToTop.prototype.onScroll = function(iScroll){
			if (this.obj.type == 'iScroll') {
				if ((-1 * iScroll.y) > this.obj.winHeight) {
					this.obj.btn.css(db);
					this.obj.show && this.obj.show(this.obj.btn);
				} else {
					this.obj.btn.css(dn);
					this.obj.hide && this.obj.hide(this.obj.btn);
				}
			} else if (this.obj.type == 'window') {
				
			}
			this.obj.onScroll && this.obj.onScroll(iScroll);
		};

		ToTop.prototype.top = function(iScroll){
			if (this.obj.type == 'iScroll') {
				if (!this.obj.scrollJudge) {
					iScroll.scrollTo(0, 0, this.obj.time);
				}
			}
		};

		return new ToTop(obj);
	}

	/*
	 * 59
	 * [getStar 根据传入的评分，返回一个五星评分结果的结构]
	 * @param  {[对象]} obj [传入的参数]
	 * @date 2016.11.04
	 * @auther Lee Chen
	 * demo 
		
	 */
	function getStar(str) {
		(typeof str != 'string') && (str = str.toString());
		(str.length == 1) && (str = str + '.0');
		switch (str.charAt(0)) {
			case '0':
				var starArr = ['width: ' + Number(str.charAt(2)) * 10 + '%;', 'width: 0;', 'width: 0;', 'width: 0;', 'width: 0;'];
				break;
			case '1':
				var starArr = ['width: 100%;', 'width: ' + Number(str.charAt(2)) * 10 + '%;', 'width: 0;', 'width: 0;', 'width: 0;'];
				break;
			case '2':
				var starArr = ['width: 100%;', 'width: 100%;', 'width: ' + Number(str.charAt(2)) * 10 + '%;', 'width: 0;', 'width: 0;'];
				break;
			case '3':
				var starArr = ['width: 100%;', 'width: 100%;', 'width: 100%;', 'width: ' + Number(str.charAt(2)) * 10 + '%;', 'width: 0;'];
				break;
			case '4':
				var starArr = ['width: 100%;', 'width: 100%;', 'width: 100%;', 'width: 100%;', 'width: ' + Number(str.charAt(2)) * 10 + '%;'];
				break;
			case '5':
				var starArr = ['width: 100%;', 'width: 100%;', 'width: 100%;', 'width: 100%;', 'width: 100%;'];
				break;
			default:
				var starArr = ['width: 100%;', 'width: 100%;', 'width: 100%;', 'width: 100%;', 'width: 100%;'];
				break;
		}

		return '<div class="star">' + 
			'<i><b style="' + starArr[0] + '"></b></i>' + 
			'<i><b style="' + starArr[1] + '"></b></i>' + 
			'<i><b style="' + starArr[2] + '"></b></i>' + 
			'<i><b style="' + starArr[3] + '"></b></i>' + 
			'<i><b style="' + starArr[4] + '"></b></i>' + 
		'</div>';
	}

	/*
	 * 60
	 * [preventLink 阻止a标签的默认点击事件，若有需要，提供tap事件]
	 * @param  {[对象]} obj [传入的参数]
	 * @date 2017.02.12
	 * @auther Lee Chen
	 * demo 
		
	 */
	function preventLink(obj) {
		var objJudge = (typeof obj == 'object');
			eleTmp = objJudge ? eleType(obj.ele) : $(obj);
		
		eleTmp.on('touchstart', ((typeof obj == 'string') ? '' : obj.selector), function (e) {
			e.preventDefault();
		}).on('click', ((typeof obj == 'string') ? '' : obj.selector), function (e) {
			e.preventDefault();
		});
		if (objJudge && obj.tap) {
			eleTmp.on('tap', obj.selector, function () {
				obj.tap($(this));
			});
		}
	}

	/*
	 * 61
	 * [layerHint 使用layer的提示窗]
	 * @param  {[对象]} obj [传入的参数]
	 * @date 2017.02.12
	 * @auther Lee Chen
	 * demo 
		
	 */
	function layerHint(data, time) {
		layer.open({
			content: data,
			skin: 'msg',
			time: time || 2 //2秒后自动关闭
		});
	}

	/*
	 * 62
	 * [hold 长按选择的事件]
	 * @param  {[对象]} obj [传入的参数]
	 * @date 2017.02.12
	 * @auther Lee Chen
	 * demo 
		
	 */
	function hold(obj) {
		function Hold(obj) {
			this.ele = obj.ele;
			this.selector = obj.selector;
			this.start = this.start || 'touchstart';
			this.end = this.end || 'touchend';
			this.timer = 0;
			this.time = obj.time;
			this.count = 0;
			this.holding = obj.hold;
			this.stopHold = obj.stopHold;

			this.ele && this.init();
		}

		Hold.prototype.init = function(){
			var _this = this;

			eleType(this.ele).on(this.start, this.selector, function () {
				_this.holding($(this));
			});
			eleType(this.ele).on(this.end, this.selector, function () {
				_this.stop();
			});
		};

		Hold.prototype.stop = function(){
			clearInterval(this.timer);
			this.count = 0;
			this.stopHold && this.stopHold();
		};

		Hold.prototype.hold = function(){
			var _this = this;

			this.timer = setInterval(function () {
				_this.count += 100;
				if (_this.count > _this.time) {
					clearInterval(_this.timer);
					_this.count = 0;
					_this.holding && _this.holding();
				}
			}, 100);
		};
		return new Hold(obj);
	}

	/*
	 * 63
	 * [centerImg 根据相册图片高宽比，将缩略图居中显示]
	 * @param  {[对象]} selector [传入的参数]
	 * @date 2017.05.08
	 * @auther Lee Chen
	 * demo 
		
	 */
	function centerImg(selector, type) {
		var $img = $(selector),
			$box = $img.parent(),
			standardWidth = $box.width(),
			standardHeight = $box.height(),
			srcArr = [];

		for (var i = 0; i < $img.length; i++) {
			srcArr.push($img.eq(i).attr('src'));
		}

		if (type == 2) {
			$img.css('width', '100%');
			$box.css('overflow', 'auto');
		}

		preLoadPic({
			files : srcArr,		// 加载的图片存储在数组中
			progress : function(precent, currentImg, index) {		// 每加载完成一张图片回调
				rateClass(index);
			}
	 	});

		// for (var i = 0; i < $img.length; i++) {
		// 	rateClass(i);
		// }

		function rateClass(i) {
			var width = $img.eq(i).width(),
				height = $img.eq(i).height(),
				rate = core.decimalRound(width / height, 2);
			if (type == 2) {
				if (height < standardHeight) {
					$img.eq(i).css('marginTop', (standardHeight - height) / 2 + 'px');
				}
			} else {
				if (rate > 1) {
					$img.eq(i).removeClass('horizontal vertical square').css({
						width: 'auto',
						height: standardHeight + 'px',
						margin: '0',
						marginLeft: (((width - standardWidth) / 2) * -1) + 'px'
					});
				} else if (rate < 1) {
					$img.eq(i).removeClass('horizontal vertical square').css({
						width: standardWidth + 'px',
						height: 'auto',
						margin: '0',
						marginTop: (((height - standardHeight) / 2) * -1) + 'px'
					});
				} else if (rate == 1) {
					$img.eq(i).removeClass('horizontal vertical square').addClass('square').css('margin', 0);
				}
			}
		}
	}

	/************************** Ajax部分 **************************/
	/*
	 * 1
	 * [ajax 使用Ajax获取后台数据并填写到相应标签中，获取的后台数据是以对象形式传输]
	 * @param  {[对象]} eleObj [传入的对象，其中定义需要传入数据的标签]
	 * @param  {[字符串]} loadUrl [传入的字符串，其中定义获取数据的链接]
	 * @param  {[字符串]} passData [传入的字符串，其中定义通过post传给url的数据]
	 * @param  {[函数]} responseFun [传入的函数，其中定义回调执行的函数]
	 * @param  {[对象]} responseObj [传入的对象，其中定义回调执行的参数]
	 * @param  {[数组]} responseArr [传入的数组，其中定义回调执行的参数]
	 * @date 2016.07.09
	 * @auther Lee Chen
	 * demo 
		var $dataEle = $('.content ul li');
		var elemObj = new (function () {
			this.id = $dataEle.eq(0);
			this.username = $dataEle.eq(1);
		})
		loadHtmlEleData(elemObj, 'inputdata.php');
	 */
	ajax();
	function ajax(obj) {
		eleReg = /^ele\d*$/gi;		// 匹配ele+数字的正则
		function Ajax() {
			this.obj = {};
		}

		Ajax.prototype.load = function(obj){
			var _this = this;
			var $body = $('body');
			obj.data = obj.data || '';
			obj.cache = obj.cache || false;

			obj.beforeLoading && obj.beforeLoading();

			if (obj.loading) {		// 显示loading图
				if (isjQuery(obj.loading)) {
					obj.loading.css(db);
				} else {
					var $pageLoading = $('#pageLoading');
				}
			}

			obj.beforeAjax && obj.beforeAjax();

			if (typeof obj.url == 'function') {
				obj.url = obj.url();
			}

			$.ajax({
				type: obj.type,
				dataType: obj.dataType,
				url: obj.url,
				data: obj.data,
				cache: obj.cache,
				jsonp: obj.jsonp,
				jsonpCallback: obj.jsonpCallback,
				success: function (data, textStatus, jqXHR) {
					if (obj.load) {
						if (typeof obj.load == 'function') {
							if (obj.load(data)) {
								importData();
							}
						} else {
							importData();
						}
					} else if (obj.load == undefined) {
						importData();
					}

					function importData() {
						// 直接导入json对象中的数据
						_this.inputData(obj, data);

						// 如果需要查找的数据在对象中的某个属性之中，则根据相应属性查找数据
						if (obj.prop) {
							for (var i in obj.prop) {
								_this.inputData(obj.prop[i], findProp(i, data));
							}
						}
					}

					if (obj.callback) {
						obj.callback(data);
					}

					_this.imgLoading(obj);

					if (obj.loading) {		// 隐藏loading图
						if (obj.removeLoading) {
							if (typeof obj.removeLoading == 'function') {
								if (obj.removeLoading(data)) {
									removeLoading();
								}
							}
						} else if (obj.removeLoading == undefined) {
							removeLoading();
						}
					}

					if (obj.afterLoading) {
						obj.afterLoading();
					}

					function removeLoading() {
						if (isjQuery(obj.loading)) {
							obj.loading.css(dn);
						} else {
							$pageLoading.css(dn);
						}
					}
				},
				error: function (XMLHttpRequest, textStatus, errorThrown) {
					obj.errHint = obj.errHint || '数据获取失败，请刷新'
					if (obj.error) {
						obj.error(XMLHttpRequest, textStatus, errorThrown);
					}
					if (obj.errHint) {
						// hint.show(obj.errHint);
						layerHint(obj.errHint);
					}
					if (obj.refresh) {
						var $refresh = $('#refresh');
						$refresh.css(db);
						$refresh.on('tap', function () {
							window.location.reload();
						})
					}
				}
			})
		};

		Ajax.prototype.imgLoading = function(obj){
			var _this = this;
			var imgObj = {};
			var imgSrcArrObj = {};
			for (var i in obj) {
				if (i.match(/imgLoading/)) {		// 实现图片loading时显示loading图，loading完成后显示图片的功能，但该方法只支持同种尺寸的图片
					imgObj[i] = obj[i].ele || $('img');
					imgSrcArrObj[i] = [];
					var srcTmp = obj[i].src || '../../images/img_loading.png';

					imgObj[i] = eleType(imgObj[i]);

					for (var j = 0; j < imgObj[i].length; j++) {
						imgSrcArrObj[i][j] = imgObj[i].eq(j).attr('src');
						imgObj[i].eq(j).attr('src', srcTmp);
					}

					obj.imgStart && obj.imgStart();

					function preLoadPicFun(attr) {
						preLoadPic({
							files: imgSrcArrObj[attr], // 加载的图片存储在数组中
							progress: function(precent, currentImg, index) { // 每加载完成一张图片回调
								imgObj[attr].eq(index).attr('src', imgSrcArrObj[attr][index]);
								obj[attr].imgComplete && obj[attr].imgComplete(imgObj[attr].eq(index), precent, currentImg, index);
							},
							complete: function () {
								obj[attr].imgAllComplete && obj[attr].imgAllComplete();
							}
						});
					}preLoadPicFun(i)
				}
			}
		};

		Ajax.prototype.addBeforeAfter = function(object, data){
			var str = '';
			if (object.before) {		// 如果需要填充在数据之前的字符串存在，则填充
				str = object.before + data;
			} else {		// 如果填充在数据之前的字符串不存在，则直接存储传入数据
				str = data;
			}
			if (object.after) {		// 如果需要填充在数据之后的字符串存在，则填充
				str += object.after;
			}
			return str;
		};

		// 导入页面数据的函数
		Ajax.prototype.inputData = function(obj, data){
			// 批量导入数据或结构
			if (obj.html) {
				this.html(obj.html, data);
			}

			// 批量导入input数据
			if (obj.val) {
				this.val(obj.val, data);
			}

			// 批量导入href属性
			if (obj.href) {
				this.href(obj.href, data);
			}

			// 批量导入src属性
			if (obj.src) {
				this.src(obj.src, data);
			}

			// 批量导入自定义属性
			if (obj.attr) {
				this.attr(obj.attr, data);
			}

			if (obj.bgz) {
				this.addBgz(obj.bgz, data);
			}
			
			if (obj.bgc) {
				this.addBgc(obj.bgc, data);
			}

			if (obj.bg) {
				this.addBg(obj.bg, data);
			}

			// 批量导入相同结构的数据
			if (obj.cycle) {
				this.cycle(obj.cycle, data)
			}

			// 批量分级循环导入数据
			if (obj.levelCycle) {
				this.levelCycle(obj.levelCycle, data)
			}

			// 批量分组导入相同结构的数据
			if (obj.group) {
				this.group(obj.group, data);
			}

			// 直接导入结构数据
			if (obj.page) {
				this.page(obj.page, data);
			}

			// 从数据中查找某个数据，若存在则提取出，批量导入结构
			if (obj.ifData) {
				ifDataCycle(obj.ifData, data);
			}
		};

		Ajax.prototype.html = function(object, data){
			for (var i in object) {		// 使用for-in语句遍历后台传入的对象属性
				this.eleInput(object[i], data[i], 'html');
			}
		};

		Ajax.prototype.val = function(object, data){
			for (var i in object) {		// 使用for-in语句遍历后台传入的对象属性
				this.eleInput(object[i], data[i], 'val');
			}
		};

		Ajax.prototype.href = function(object, data){
			for (var i in object) {		// 使用for-in语句遍历后台传入的对象属性
				if (data[i] == '') {
					this.eleInput(object[i], object[i].demohref, 'href');
				} else {
					this.eleInput(object[i], data[i], 'href');
				}
			}
		};

		Ajax.prototype.src = function(object, data){
			for (var i in object) {		// 使用for-in语句遍历后台传入的对象属性
				if (data[i] == '') {
					this.eleInput(object[i], object[i].demoSrc, 'src');
				} else {
					this.eleInput(object[i], data[i], 'src');
				}
			}
		};

		Ajax.prototype.attr = function(object, data){
			for (var i in object) {
				if (data[i] == '') {
					this.eleInput(object[i], object[i].demoAttr, 'attr', i);
				} else {
					this.eleInput(object[i], data[i], 'attr', i);
				}
			}
		};

		// 区分传入对象是否jQuery对象后，将对象传入标签，并支持直接传入或在前或后插入字符串
		Ajax.prototype.eleInput = function(object, data, type, attr) {
			var _this = this;

			function dataInput(object, obj, data) {
				if (obj.type == 'html' || type == 'html') {
					object.html(data);
				} else if(obj.type == 'val' || type == 'val') {
					object.val(data);
				} else if (obj.type == 'href' || type == 'href') {
					object.attr({
						href: data
					});
				} else if (obj.type == 'src' || type == 'src') {
					object.attr({
						src: data
					});
					var loading = obj.loading || object.loading;
					if (loading) {
						loading.css({
							display: 'block'
						})
						preLoadPic({
							files: [data],
							complete: function () {
								loading.css({
									display: 'none'
								});
							}
						})
					}
				} else if (obj.type == 'attr' || type == 'attr') {
					var attrObj = {};
					if ($.isPlainObject(obj)) {
						if (obj.attr) {
							attrObj[obj.attr] = data;
						} else {
							attrObj[attr] = data;
						}
					} else {
						attrObj[attr] = data;
					}
					object.attr(attrObj);
				}
			}

			if (isjQuery(object)) {
				dataInput(object, object, data)
			} else if ((typeof object == 'string') || (typeof object == 'function')) {
				dataInput(eleType(object), object, data);
			} else {
				var str = _this.addBeforeAfter(object, data);
				for (var i in object) {
					if (i.match(eleReg)) {		// 若ele属性存在，则将相应数据传入ele对应的标签中
						if (isjQuery(object[i])) {
							dataInput(object[i], object, str);
						} else {
							object.attr ? this.eleInput(object[i], str, type, object.attr) : this.eleInput(object[i], str, type);
						}
					}
				}
			}
		};

		// 增加背景图，background-size为100% 100%
		Ajax.prototype.addBgz = function(object, data) {
			for (var i in object) {
				object[i].ele.css({
					background: 'url(' + data[i] + ') 0px 0px no-repeat',
					'-webkit-background-size': '100% 100%',
					'-moz-background-size': '100% 100%',
					'-ms-background-size': '100% 100%',
					'-o-background-size': '100% 100%',
					'background-size': '100% 100%'
				});
			}
		};

		// 增加背景图，background-size为contain
		Ajax.prototype.addBgc = function(object, data) {
			for (var i in object) {
				object[i].ele.css({
					background: 'url(' + data[i] + ') 0 0 no-repeat',
					'-webkit-background-size': 'contain',
					'-moz-background-size': 'contain',
					'-ms-background-size': 'contain',
					'-o-background-size': 'contain',
					'background-size': 'contain'
				})
			}
		}

		// 增加背景图，background-size为只定义
		Ajax.prototype.addBg = function(object, data) {
			for (var i in object) {
				var bg = object[i].bg || '0 0 no-repeat';
				object[i].ele.css({
					background: 'url(' + data[i] + ')' + bg,
					'-webkit-background-size': object[i].bgz,
					'-moz-background-size': object[i].bgz,
					'-ms-background-size': object[i].bgz,
					'-o-background-size': object[i].bgz,
					'background-size': object[i].bgz
				});
			}
		}

		// 批量导入相同结构的数据
		Ajax.prototype.cycle = function(object, data) {
			this.obj.cycle = {};
			if (object.eleFun) {
				var objTmp = {},
					dataTmp = {};
				this.obj.cycle = {};
				this.obj.cycle.prop = object;
				this.obj.cycle.prop.html = '';
				this.obj.cycle.prop.ele = eleType(object.ele);
				objTmp.prop = object;
				dataTmp.prop = data;
				this.cycleData(objTmp, dataTmp);
			} else {
				for (var i in object) {
					this.obj.cycle[i] = {};
					this.obj.cycle[i].html = '';
					this.obj.cycle[i].ele = eleType(object[i].ele);
				}
				this.cycleData(object, data);
			}
		}

		// 批量导入相同结构的数据
		Ajax.prototype.cycleData = function(object, data, ancestorProp, ancestorJudge) {
			for (var i in object) {
				if (ancestorProp) {
					this.eleTypeJudge(object[i], data[i], ancestorProp, ancestorJudge);
				} else {
					this.eleTypeJudge(object[i], data[i], i, true);
				}
			}
		}

		// 判断ele属性存储数据是否为jQuery对象，如果是则直接导入数据，如果不是则提取其内部的ele属性导入数据
		Ajax.prototype.eleTypeJudge = function(object, data, propName, ancestorJudge) {
			for (var i in object) {
				if (i.match(eleReg)) {		// 如果属性为ele+数字，则表示该属性需要导入数据
					if (isjQuery(object[i])) {		// 判断是否为jQuery对象
						this.cycleHtml(object, object[i], data, object.eleFun, object.num, object.group, object.cycle, object.lenEle, object.active, object.noData, object.loading, propName, ancestorJudge);
					} else if (typeof object[i] == 'function') {		// 如果需要动态获取标签，则ele属性以函数形式传入，此时通过运行函数获取标签之后传入数据
						this.cycleHtml(object, object[i](), data, object.eleFun, object.num, object.group, object.cycle, object.lenEle, object.active, object.noData, object.loading, propName, ancestorJudge);
					} else if (typeof object[i] == 'string') {
						this.cycleHtml(object, object[i], data, object.eleFun, object.num, object.group, object.cycle, object.lenEle, object.active, object.noData, object.loading, propName, ancestorJudge);
					} else if ($.isPlainObject(object[i])) {		// 如果不是jQuery对象
						for (var l in object[i]) {
							if (l.match(eleReg)) {		// 提取其中存储jQuery对象的属性，导入数据
								this.cycleHtml(object[i], object[i][l], data, object.eleFun, object.num, object.group, object.cycle, object.lenEle, object.active, object.noData, object.loading, propName, ancestorJudge);
							}
						}
					}
				}
			}
		}

		// 批量导入结构
		Ajax.prototype.cycleHtml = function(object, element, data, eleFun, num, group, cycle, lenEle, active, noData, loading, propName, ancestorJudge) {
			if (data) {
				var eleJudge = false;
				var dataLen = data.length;
				var elementStr = '';
				// object.addHtml = '';

				eleFun = object.eleFun || eleFun;
				if (!$.isArray(object.noData)) {
					noData = eleType(object.noData || noData);		// 设定无数据时显示的元素
				}
				
				if (dataLen == 0) {		// 若无数据且无数据显示元素存在，则显示
					if (object.clear) {
						element.empty();
					}
					if (noData) {
						noData.css(db)
					}
				} else {
					if (noData) {		// 有数据时，将无数据显示元素隐藏
						noData.css(dn)
					}
				}

				if (typeof element == 'function') {
					element = element();
				} else if (typeof element == 'string') {
					if (element.charAt(0) == '<') {
						eleJudge = true;
					} else {
						element = $(element);
					}
				}
				group = object.group || group;
				cycle = object.cycle || cycle;
				num = object.num || num;
				loading = object.loading || loading;
				
				if (loading) {
					var preloadArr = [];
				}

				if (object.clear) {
					element.empty();
				}
					
				for (var i = 0; i < dataLen; i++) {
					if (object.demoSrc) {		// 如果demoSrc属性存在且为空或未定义，则用demoSrc的src属性中的地址替换
						for (var j in data[i]) {
							if (j == object.demoSrc.prop) {		// 选取demoSrc中的prop属性所对应的属性，即src地址的属性
								if (data[i][j] == undefined || data[i][j] == '') {		// 如果为空，则使用src属性中的值替换
									data[i][j] = object.demoSrc.src;
								}
							}
						}
					}
					// object.addHtml = eleFun(data[i], i, dataLen);
					
					// element.append(object.addHtml);
					
					// 数据导入到html字符串中
					if (eleJudge) {
						elementStr += eleFun(data[i], i, dataLen);
					} else {
						this.obj.cycle[propName].html += eleFun(data[i], i, dataLen);
					}

					group && this.group(group, data[i], element.children().last());

					if ((i == dataLen - 1) && ancestorJudge) {
						cycle && this.cycleData(cycle, data[i], propName, true);
					} else {
						cycle && this.cycleData(cycle, data[i], propName);
					}
					
					if (num - 1 == i) {		// 达到最大显示数量时，则停止循环
						break;
					}

					if (loading) {		// 将加载中的src存入数组
						if (loading.src) {
							preloadArr.push(data[i][loading.src]);
						} else {
							preloadArr.push(data[i]);
						}
					}
				}

				// 数据导入到html字符串中
				if (eleJudge) {
					var elementMatch = element.match(/([<].*[>])([<].*[>])/);
					if (elementStr) {
						this.obj.cycle[propName].html = this.obj.cycle[propName].html.replace(element, elementMatch[1] + elementStr + elementMatch[2]);
					} else {
						this.obj.cycle[propName].html = this.obj.cycle[propName].html.replace(element, elementMatch[1] + '<b style="display:none;"></b>' + elementMatch[2]);
					}
				}

				(((i == dataLen - 1) && (!group && !cycle)) && ancestorJudge) && console.log(this.obj.cycle[propName].html);

				(((i == dataLen) && (!group && !cycle)) && ancestorJudge) && this.obj.cycle[propName].ele.append(this.obj.cycle[propName].html);

				// 实现图片预加载后回调
				if (loading) {
					element.find(loading.ele).css(db);		// 将所有的加载中元素都显示
					preLoadPic({
						files: preloadArr, // 加载的图片存储在数组中
						progress: function(precent, currentImg, index) { // 每加载完成一张图片回调
							element.find(loading.ele).eq(index).css(dn);		// 当一张图片加载完成之后，将相应的加载中元素隐藏
						},
					})
				}

				object.addHtml = undefined;		// 清除addHtml在内存中的数据

				lenEle = object.lenEle || lenEle;
				if (lenEle) {		// 如果需要存储分组数量的标签数组存在
					if (isjQuery(lenEle)) {		// 如果存储分组数量的标签值为jQuery对象
						lenEle.html(dataLen);		// 将存储分组数据的数组长度即数据个数存入标签
					} else {
						for (var k in lenEle) {
							if (k.match(eleReg)) {		// 选取ele+数字的属性，为该属性添加值
								lenEle[k].html(addBeforeAfter(lenEle, dataLen));		// 如果有预设数据前后的值，则填充到数据前后再导入标签
							}
						}
					}
				}

				active = object.active || active;
				if (active) {		// 在循环出的结构中，给特定标签添加类名和CSS属性
					if (active.index || active.index == 0) {		// 通过传入的索引值决定添加类名和CSS属性的标签
						activeCss(active, element, active.index);
					} else if (active.prop) {		// 通过传入的属性值是否与标签属性想等，决定添加类名和CSS属性的标签
						for (var l = 0; l < element.children().length; l++) {
							for (var m in active.prop) {
								if (element.children().eq(l).attr(m) == active.prop[m]) {
									activeCss(active, element, l);
								}
							}
						}
					}
				}

				function activeCss(object, ele, index) {
					if (object.class) {
						ele.children().eq(index).addClass(object.class);
					}
					if (object.css) {
						ele.children().eq(index).css(object.css);
					}
				}
			}
			
		}

		// 批量分组导入结构的数据的函数
		Ajax.prototype.group = function(object, data, element) {
			for (var i in object) {
				object[i].addHtml = '';		// 创建一个存储添加数据的结构的变量
				object[i].parentHtml = '';		// 创建一个存储添加数据分组父级的变量
				object[i].dataLen = data[i].length;		// 存储要添加的数据长度
				object[i].groupLen = Math.ceil(object[i].dataLen / object[i].eleNum);		// 存储数据的组数量
				for (var s = 0; s < object[i].groupLen; s++) {		// 使用for循环批量添加相应组数量的数据父级
					object[i].parentHtml += object[i].groupEle;		// 将数据组父级的结构添加到变量中
				}
				var $groupELe = {};
				if (element) {
					$groupELe = element.find(object[i].ele);
				} else {
					$groupELe = $(object[i].ele);
				}
				$groupELe.html(object[i].parentHtml);		// 添加相应数据组的父级结构
				if (object[i].loading) {
					var preloadArr = [];
				}
				for (var s = 0; s < object[i].dataLen; s++) {
					object[i].addHtml = '';
					if (object[i].loading) {
						if (object[i].loading.src) {
							preloadArr.push(data[i][s][object[i].loading.src]);
						} else {
							preloadArr.push(data[i][s]);
						}
					}
					
					for (var t = 0; t < object[i].eleNum; t++) {
						if (data[i][s * object[i].eleNum + t] != undefined) {
							object[i].addHtml += object[i].eleFun(data[i][s * object[i].eleNum + t]);
						}
					}
					$groupELe.children().eq(s).html(object[i].addHtml);
				}
				// 实现图片预加载后回调
				if (object[i].loading) {
					if (isjQuery(object[i].ele) == undefined) {
						if (typeof object[i].ele == 'string') {
							var objTmp = element.find(object[i].ele);
						} else {
							var objTmp = object[i].ele();
						}
					} else {
						objTmp = object[i].ele
					}
					objTmp.find(object[i].loading.ele).css({		// 将所有的加载中元素都显示
						display: 'block'
					})
					preLoadPic({
						files: preloadArr, // 加载的图片存储在数组中
						progress: function(precent, currentImg, index) { // 每加载完成一张图片回调
							objTmp.find(object[i].loading.ele).eq(index).css({		// 当一张图片加载完成之后，将相应的加载中元素隐藏
								display: 'none'
							})
						},
					});
				}
			}
		}

		// 批量分级循环导入数据
		Ajax.prototype.levelCycle = function(object, data, refreshJudge){
			this.obj.levelCycle = {};
			if (object.eleFun && !object.ele) {
				var objTmp = {},
					dataTmp = {};
				this.obj.levelCycle = {};
				this.obj.levelCycle.prop = object;
				this.obj.levelCycle.prop.html = '';
				objTmp.prop = object;
				dataTmp.prop = data;
				if (refreshJudge) {
					for (var i = 0; i < objTmp.prop.ele.length; i++) {
						objTmp.prop.ele[i].empty();
					}
				}
				this.levelCycleData(objTmp, dataTmp);
			} else {
				for (var i in object) {
					this.obj.levelCycle[i] = {};
					this.obj.levelCycle[i].html = '';
					this.obj.levelCycle[i].ele = eleType(object[i].ele);
					if (refreshJudge) {
						for (var j = 0; j < this.obj.levelCycle[i].ele.length; j++) {
							this.obj.levelCycle[i].ele[j].empty();
						}
					}
				}
				this.levelCycleData(object, data);
			}
		};

		Ajax.prototype.levelCycleData = function(object, data) {
			var levelObj = {};		// 定义临时数组存储
			for (var i in object) {
				levelObj[i] = [];
				var levelLen = object[i].level.length;
				for (var j = 0; j < levelLen; j++) {		// 创建一个数组存储
					levelObj[i][j] = [];
				}
				for (var k = 0; k < data[i].length; k++) {		// 获取每个属性中需要循环的每个值所对应的对象
					for (var l in data[i][k]) {		// 遍历每个对象中的属性值
						if (l == object[i].levelProp) {		// 查找到用来分级的属性值
							for (var n = 0; n < levelLen; n++) {		// 遍历等级标准数组
								object[i].level[n] = object[i].level[n].toString();
								if (object[i].level[n].match(/-/)) {		// 如果分级标准为1-2类型则执行分级
									var levelArrTmp = object[i].level[n].split('-');		// 提取出分级标准的最小值和最大值
									if (data[i][k][l] >= levelArrTmp[0] && data[i][k][l] <= levelArrTmp[1]) {		// 当分级的值在分级标准的范围内时运行（分级标准为>=和<=）
										levelObj[i][n].push(data[i][k]);		// 将提取出的各等级数据存储在数组中
									}
								} else {
									if (object[i].level[n] == data[i][k][l]) {
										levelObj[i][n].push(data[i][k]);
									}
								}
							}
						}
					}
				}
				for (var n = 0; n < object[i].ele.length; n++) {
					if (object[i].levelLenEle) {		// 如果需要存储分组数量的标签数组存在
						if (isjQuery(object[i].levelLenEle[n])) {		// 如果存储分组数量的标签值为jQuery对象
							object[i].levelLenEle[n].html(levelObj[i][n].length);		// 将存储分组数据的数组长度即数据个数存入标签
						} else {
							for (var o in object[i].levelLenEle[n]) {
								if (o.match(eleReg)) {		// 选取ele+数字的属性，为该属性添加值
									object[i].levelLenEle[n][o].html(addBeforeAfter(object[i].levelLenEle[n], levelObj[i][n].length));		// 如果有预设数据前后的值，则填充到数据前后再导入标签
								}
							}
						}
					}
					this.obj.cycle[i].html = '';
					this.obj.cycle[i].ele = object[i].ele[n];
					this.cycleHtml(object[i], object[i].ele[n], levelObj[i][n], object[i].eleFun, object[i].num, object[i].group, object[i].cycle, object[i].lenEle, object[i].active, object[i].noData[n], object[i].loading, i, true);
				}
			}
		}

		// 直接导入结构或者从传入的结构中提取出
		Ajax.prototype.page = function (object, data) {
			if (object.getHtml) {
				object.ele.html(getHtml(data, object.getHtml, object.inside));
			} else {
				object.ele.html(data);
			}
		}

		// 从数据中查找某个数据，若存在则提取出，批量导入结构
		Ajax.prototype.ifDataCycle = function(object, data) {
			for (var i in object) {
				if (object[i].array) {
					var dataArr = [];
					for (var k = 0; k < data[i].length; k++) {
						if (data[i][k][object[i].array].length > 0) {
							dataArr.push(data[i][k])
						}
					}

					var dataArrLen = dataArr.length;
					
					if (isjQuery(object[i].lenEle)) {
						object[i].lenEle.html(dataArrLen)
					} else {
						object[i].lenEle.ele.html(addBeforeAfter(object[i].lenEle, dataArrLen));
					}

					if (dataArrLen > 0) {
						cycleHtml(object[i], object[i].ele, dataArr, object[i].eleFun, object[i].num, object[i].group, object[i].cycle, object[i].lenEle, object[i].active, object[i].noData, object[i].loading);
					} else {
						if (object[i].noData) {
							object[i].noData.css({
								display: 'block'
							})
						}
					}
					
				}
			}
		}

		Ajax.prototype.lazy = function(obj){
			return new Lazy(obj);
		};

		function Lazy(obj){
			this.obj = obj;

			this.init(obj);
		};

		Lazy.prototype.init = function(obj){
			var _this = this;		// 定义变量存储当前this指向，以便在事件中调用使用
			
			if (this.obj.device == 'mobile' || this.obj.device == undefined) {		// 判断设备类型，true为移动设备，false为pc
				this.obj.device = true;
			} else if (this.obj.device == 'pc') {
				this.obj.device = false;
			}
			
			this.obj.loading = false;
			
			function getEle(type) {
				(type == 'lazyRefresh') && (obj[type] = $('.lazy-refresh'));
				(type == 'lazyLoading') && (obj[type] = $('.lazy-loading'));
				var arrTmp = obj[type];
				_this.obj[type] = [];

				if (isjQuery(arrTmp)) {
					for (var i = 0; i < arrTmp.length; i++) {
						_this.obj[type].push(arrTmp.eq(i));
					}
				} else if ($.isArray(arrTmp)) {
					for (var i = 0; i < arrTmp.length; i++) {
						if (arrTmp[i]) {
							if (isjQuery(arrTmp[i])) {
								_this.obj[type][i] = arrTmp[i];
							} else if (typeof arrTmp[i] == 'string') {
								_this.obj[type][i] = $(arrTmp[i]);
							} else if (typeof arrTmp[i] == 'function') {
								_this.obj[type][i] = arrTmp[i]();
							}
						} else {
							(type == 'win') && (_this.arrTmp[i] = $(window));
							(type == 'con') && (_this.arrTmp[i] = $('body'));
							(type == 'lazyRefresh') && (_this.arrTmp[i] = obj[type].eq(i));
							(type == 'lazyLoading') && (_this.arrTmp[i] = obj[type].eq(i));
						}
					}
				} else if (typeof arrTmp == 'string') {
					var $eleTmp = $(arrTmp);
					for (var i = 0; i < $eleTmp.length; i++) {
						_this.obj[type].push($eleTmp.eq(i));
					}
				} else if (typeof arrTmp == 'function') {
					var $eleTmp = arrTmp();
					for (var i = 0; i < $eleTmp.length; i++) {
						_this.obj[type].push($eleTmp.eq(i));
					}
				}
			}

			if (this.obj.selector == undefined) {
				this.obj.selector = [];
				if ($.isArray(this.obj.con)) {
					for (var i = 0; i < this.obj.con.length; i++) {
						if ($.isArray(this.obj.win)) {
							if (typeof this.obj.win[i] == 'string') {
								this.obj.selector[i] = this.obj.win[i];
							}
						} else if (typeof this.obj.win == 'function') {
							this.obj.selector[i] = this.obj.win(i);
						} else if (typeof this.obj.win == 'string') {
							this.obj.selector[i] = this.obj.win;
						}
					}
				} else if (typeof this.obj.con == 'string') {
					if (typeof this.obj.win == 'string') {
						this.obj.selector[0] = this.obj.win;
					}
				}
			} else if (typeof this.obj.selector == 'string') {
				this.obj.selector[0] = this.obj.selector;
			}
			getEle('win');
			getEle('con');
			getEle('noData');

			if (this.obj.device) {
				var numTmp = obj.startNum || 0,
					winHeightTmp = obj.winHeight,
					refreshJudge;

				this.obj.showNoDataTime = (this.obj.showNoDataTime == undefined) ? 1000 : this.obj.showNoDataTime;
				this.obj.ajaxing = [];
				this.obj.num = [];		// 定义加载数据的次数
				this.obj.winHeight = [];
				this.obj.lazyRefresh = [];
				this.obj.lazyLoading = [];
				// this.obj.noData = [];
				this.obj.startNum = [];
				this.obj.loadJudge = [];		// 定义判断是否在加载中的布尔值
				this.obj.tabJudge = [];
				this.obj.activeTab = obj.activeTab || 0;
				this.obj.refreshJudge = [];
				this.obj.refreshingJudge = [];
				this.obj.lazyJudge = [];
				this.obj.startY = [];
				this.obj.moveY = [];
				this.obj.tmpY = [];
				this.obj.preMoveY = [];
				this.obj.direction = [];
				this.obj.firstTouch = [];		// 判断是否第一次滑动
				this.obj.firstDirection = [];		// 判断第一次滑动的方向
				this.obj.iScroll = [];
				this.obj.scroller = [];
				this.obj.refreshHeight = [];
				this.obj.lazyHeight = [];
				this.obj.topJudge = [];
				this.obj.isStartRefreshJudge = [];
				this.obj.isRefreshJudge = [];
				this.obj.noDataJudge = [];
				this.obj.isNoData = [];
				this.obj.loadingType = obj.loadingType || 1;
				this.obj.beforeRefreshCSS = this.obj.beforeRefreshCSS || {};
				this.obj.beforeRefreshHtml = this.obj.beforeRefreshHtml || '下拉刷新~';
				this.obj.availableRefreshCSS = this.obj.availableRefreshCSS || {};
				this.obj.availableRefreshHtml = this.obj.availableRefreshHtml || '释放刷新~';
				this.obj.refreshingCSS = this.obj.refreshingCSS || {};
				this.obj.refreshingHtml = this.obj.refreshingHtml || '刷新中~';
				this.obj.beforeLoadingCSS = this.obj.beforeLoadingCSS || {};
				this.obj.beforeLoadingHtml = this.obj.beforeLoadingHtml || '上拉加载更多~';
				this.obj.availableLoadingCSS = this.obj.availableLoadingCSS || {};
				this.obj.availableLoadingHtml = this.obj.availableLoadingHtml || '释放加载更多~';
				this.obj.loadingCSS = this.obj.loadingCSS || {};
				this.obj.loadingHtml = this.obj.loadingHtml || '加载中~';
				this.obj.noLoadingDataCSS = this.obj.noLoadingDataCSS || {};
				this.obj.noLoadingDataHtml = this.obj.noLoadingDataHtml || '没有数据了~';
				this.obj.noDataCSS = this.obj.noDataCSS || {};
				this.obj.noDataHtml = this.obj.noDataHtml || '暂无数据~';

				if (typeof this.obj.refresh == 'boolean') {
					refreshJudge = this.obj.refresh;
				} else if (this.obj.refresh == undefined) {
					refreshJudge = true;
				}
				this.obj.refresh = [];

				if (obj.loadingType == 1) {
					function refresh() {
						if (((-1 * _this.obj.refreshHeight[_this.obj.activeTab]) < _this.obj.iScroll[_this.obj.activeTab].y) && (_this.obj.iScroll[_this.obj.activeTab].y < 0)) {
							_this.obj.lazyRefresh[_this.obj.activeTab].css(_this.obj.beforeRefreshCSS).html(_this.obj.beforeRefreshHtml);
							_this.obj.refreshJudge[_this.obj.activeTab] = false;
						} else if (_this.obj.iScroll[_this.obj.activeTab].y > 0) {
							_this.obj.lazyRefresh[_this.obj.activeTab].css(_this.obj.availableRefreshCSS).html(_this.obj.availableRefreshHtml).addClass('lazy-available-refresh').removeClass('lazy-invalid-refresh lazy-refreshing');
							_this.obj.refreshJudge[_this.obj.activeTab] = true;
						}
					}
				} else {
					// function refresh() {
					// 	if (_this.obj.preMoveY[_this.obj.activeTab]) {
					// 		var dif = Math.abs(event.touches[0].clientY) - Math.abs(_this.obj.preMoveY[_this.obj.activeTab]);
					// 	}
						
					// 	(_this.obj.preMoveY[_this.obj.activeTab] < event.touches[0].clientY) ? (_this.obj.direction[_this.obj.activeTab] = true) : (_this.obj.direction[_this.obj.activeTab] = false);

					// 	if (_this.obj.firstTouch[_this.obj.activeTab]) {
					// 		if (dif) {
					// 			if (dif > 0) {
					// 				_this.obj.firstDirection[_this.obj.activeTab] = true;
					// 			} else {
					// 				_this.obj.firstDirection[_this.obj.activeTab] = false;
					// 			}
					// 			_this.obj.firstTouch[_this.obj.activeTab] = false;
					// 		}
					// 	}

					// 	if (_this.obj.firstDirection[_this.obj.activeTab]) {
					// 		if (_this.obj.preMoveY[_this.obj.activeTab]) {
					// 			_this.obj.tmpY[_this.obj.activeTab] += dif;
					// 			(_this.obj.tmpY[_this.obj.activeTab] < 0) && (_this.obj.tmpY[_this.obj.activeTab] = 0);
					// 		}

					// 		if (_this.obj.tmpY[_this.obj.activeTab] < _this.obj.refreshHeight[_this.obj.activeTab]) {
					// 			_this.obj.moveY[_this.obj.activeTab] = _this.obj.tmpY[_this.obj.activeTab];
					// 		} else {
					// 			_this.obj.moveY[_this.obj.activeTab] = _this.obj.refreshHeight[_this.obj.activeTab] + (_this.obj.tmpY[_this.obj.activeTab] - _this.obj.refreshHeight[_this.obj.activeTab]) * (200 / (_this.obj.tmpY[_this.obj.activeTab]))
					// 		}

					// 		if (_this.obj.moveY[_this.obj.activeTab] + _this.obj.iScroll[_this.obj.activeTab].y > 0) {
					// 			_this.obj.con[_this.obj.activeTab].css(core.trfObj('translate(0px, ' + _this.obj.moveY[_this.obj.activeTab] + 'px) translateZ(0px)'));
					// 			_this.obj.lazyRefresh[_this.obj.activeTab].css(core.trfObj('translate(0px, ' + _this.obj.moveY[_this.obj.activeTab] + 'px) translateZ(0px)'));
					// 		}
					// 		if ((_this.obj.moveY[_this.obj.activeTab] + _this.obj.iScroll[_this.obj.activeTab].y) >= _this.obj.refreshHeight[_this.obj.activeTab]) {
					// 			_this.obj.lazyRefresh[_this.obj.activeTab].css(_this.obj.availableRefreshCSS).html(_this.obj.availableRefreshHtml);
					// 			if (_this.obj.isStartRefreshJudge[_this.obj.activeTab]) {
					// 				_this.obj.isRefreshJudge[_this.obj.activeTab] = true;
					// 				_this.obj.isStartRefreshJudge[_this.obj.activeTab] = false;
					// 			}
					// 		} else {
					// 			_this.obj.lazyRefresh[_this.obj.activeTab].css(_this.obj.beforeRefreshCSS).html(_this.obj.beforeRefreshHtml);
					// 		}
					// 	}
					// 	_this.obj.preMoveY[_this.obj.activeTab] = event.touches[0].clientY;
					// }

					// function lazyLoading() {
					// 	if (!_this.obj.firstDirection[_this.obj.activeTab]) {
					// 		if (Math.abs(_this.obj.iScroll[_this.obj.activeTab].y) > (_this.obj.scroller[_this.obj.activeTab].height() - _this.obj.win[_this.obj.activeTab].height() - _this.obj.lazyHeight[_this.obj.activeTab])) {
					// 			_this.obj.lazyJudge[_this.obj.activeTab] = true;
					// 			_this.obj.lazyLoading[_this.obj.activeTab].css(_this.obj.availableLoadingCSS).html(_this.obj.availableLoadingHtml);
					// 		} else {
					// 			_this.obj.lazyJudge[_this.obj.activeTab] = false;
					// 			_this.obj.lazyLoading[_this.obj.activeTab].css(_this.obj.beforeLoadingCSS).html(_this.obj.beforeLoadingHtml);
					// 		}
					// 	}
					// }
				}

				for (var i = 0; i < this.obj.con.length; i++) {
					if ($.isArray(numTmp)) {
						this.obj.num[i] = numTmp[i] || 1;		// 定义加载数据的次数
						this.obj.startNum[i] = numTmp[i] || 1;
					} else {
						this.obj.num[i] = numTmp || 1;		// 定义加载数据的次数
						this.obj.startNum[i] = numTmp || 1;
					}
					
					(typeof refreshJudge == 'boolean') && (this.obj.refresh[i] = refreshJudge);
					this.obj.ajaxing[i] = false;
					this.obj.refresh[i] && this.obj.win[i].children().first().children().first().before('<div class="lazy-refresh"></div>');
					this.obj.lazyRefresh[i] = $('.lazy-refresh').eq(i);
					this.obj.win[i].children().first().children().last().after('<div class="lazy-loading"></div>');
					this.obj.lazyLoading[i] = $('.lazy-loading').eq(i);
					this.obj.loadJudge[i] = true;		// 定义判断是否在加载中的布尔值
					this.obj.tabJudge[i] = true;
					this.obj.refreshJudge[i] = false;
					this.obj.refreshingJudge[i] = false;
					this.obj.lazyJudge[i] = false;
					this.obj.startY[i] = 0;
					this.obj.moveY[i] = 0;
					this.obj.tmpY[i] = 0;
					this.obj.preMoveY[i] = 0;
					this.obj.direction[i];
					this.obj.firstTouch[i] = true;		// 判断是否第一次滑动
					this.obj.firstDirection[i] = false;		// 判断第一次滑动的方向
					this.obj.isStartRefreshJudge[i] = true;
					this.obj.isRefreshJudge[i] = false;
					this.obj.noDataJudge[i] = false;
					this.obj.isNoData[i] = false;
					this.obj.refresh[i] && (this.obj.refreshHeight[i] = this.obj.lazyRefresh[i].height());
					this.obj.lazyHeight[i] = this.obj.lazyLoading[i].height();
					this.obj.refresh[i] && this.obj.lazyRefresh[i].css(_this.obj.beforeRefreshCSS).html(_this.obj.beforeRefreshHtml).addClass('lazy-invalid-refresh').removeClass('lazy-available-refresh lazy-refreshing');
					this.obj.lazyLoading[i].css(_this.obj.loadingCSS).html(_this.obj.loadingHtml).addClass('lazy-loading-data').removeClass('lazy-invalid-loading lazy-available-loading lazy-no-data');

					if ($.isArray(winHeightTmp)) {
						this.obj.win[i].height(winHeightTmp[i]);
					} else if (typeof winHeightTmp == 'number') {
						this.obj.win[i].height(winHeightTmp);
						this.obj.winHeight[i] = winHeightTmp;
					} else {
						this.obj.winHeight[i] = this.obj.win[i].height();
					}

					if (obj.loadingType == 1) {
						if (this.obj.refresh[i]) {
							if ($.isArray(obj.selector)) {
								this.obj.iScroll[i] = new IScroll(obj.selector[i], {probeType: 3, startY: -1 * _this.obj.refreshHeight[i], click: true});
							} else if (typeof obj.selector == 'function') {
								this.obj.iScroll[i] = new IScroll(obj.selector(i), {probeType: 3, startY: -1 * _this.obj.refreshHeight[i], click: true});
							} else {
								this.obj.iScroll[i] = new IScroll(obj.selector, {probeType: 3, startY: -1 * _this.obj.refreshHeight[i], click: true});
							}
						} else {
							if ($.isArray(obj.selector)) {
								this.obj.iScroll[i] = new IScroll(obj.selector[i], {probeType: 3, click: true, bounce: false, mouseWheel: true, scrollbars: true, fadeScrollbars: true});
							} else if (typeof obj.selector == 'function') {
								this.obj.iScroll[i] = new IScroll(obj.selector(i), {probeType: 3, click: true, bounce: false, mouseWheel: true, scrollbars: true, fadeScrollbars: true});
							} else {
								this.obj.iScroll[i] = new IScroll(obj.selector, {probeType: 3, click: true, bounce: false, mouseWheel: true, scrollbars: true, fadeScrollbars: true});
							}
						}

						this.obj.scroller[i] = $(this.obj.iScroll[i].scroller);
						
						if (this.obj.refresh[i]) {
							this.obj.scroller[i].on('touchstart', function (num) {
								return function () {
									_this.obj.activeTab = num;
									_this.obj.scroller[num].on('touchmove',refresh);
								}
							}(i));

							this.obj.scroller[i].on('touchend', function (num) {
								return function () {
									if (_this.obj.refreshJudge[num]) {
										_this.obj.lazyRefresh[num].css(_this.obj.refreshingCSS).html(_this.obj.refreshingHtml).addClass('lazy-refreshing').remvoeClass('lazy-invalid-refresh lazy-available-refresh');
										_this.ajax(num, _this.obj.startNum[num]);
									}
									_this.obj.scroller[num].off('touchmove', refresh);
								}
							}(i));
						}

						_this.addEvent(i);

					} else {
						// if ($.isArray(obj.selector)) {
						// 	this.obj.iScroll[i] = new IScroll(obj.selector[i], {probeType: 3, click: true, tap: true, bounce: false, momentum: true});
						// } else if (typeof obj.selector == 'function') {
						// 	this.obj.iScroll[i] = new IScroll(obj.selector(i), {probeType: 3, click: true, tap: true, bounce: false, momentum: true});
						// } else {
						// 	this.obj.iScroll[i] = new IScroll(obj.selector, {probeType: 3, click: true, tap: true, bounce: false, momentum: true});
						// }
						
						// this.obj.scroller[i] = $(this.obj.iScroll[i].scroller);

						// this.obj.con[i].on('touchstart', function (num) {
						// 	return function () {
						// 		_this.obj.activeTab = num;
						// 		if (Math.abs(_this.obj.iScroll[num].y) < 1) {
						// 			_this.obj.topJudge[num] = true;
						// 			_this.obj.startY[num] = event.touches[0].clientY;

						// 			_this.obj.con[num].on('touchmove',refresh);
						// 		} else {
						// 			_this.obj.topJudge[num] = false;
						// 		}
						// 		_this.obj.con[num].on('touchmove', lazyLoading);
						// 	}
						// }(i));

						// this.obj.con[i].on('touchend', function (num) {
						// 	return function () {
						// 		if (_this.obj.direction[num]) {
						// 			if (_this.obj.moveY[num] < _this.obj.refreshHeight[num]) {
						// 				_this.obj.con[num].animate(core.trfObj('translate(0px, 0px) translateZ(0px)'), 300, 'ease');
						// 				_this.obj.lazyRefresh[num].animate(core.trfObj('translate(0px, 0px) translateZ(0px)'), 300, 'ease');
						// 			} else {
						// 				_this.obj.con[num].animate(core.trfObj('translate(0px, ' + _this.obj.refreshHeight + 'px) translateZ(0px)'), 300, 'ease');
						// 				_this.obj.lazyRefresh[num].animate(core.trfObj('translate(0px, ' + _this.obj.refreshHeight[num] + 'px) translateZ(0px)'), 300, 'ease', function () {
						// 					_this.obj.lazyRefresh[num].css(_this.obj.refreshingCSS).html(_this.obj.refreshingHtml);
						// 				});
						// 			}
						// 		} else if (_this.obj.firstDirection[num] && !_this.obj.direction[num]) {
									
						// 		}

						// 		if ((_this.obj.moveY[_this.obj.activeTab] + _this.obj.iScroll[_this.obj.activeTab].y) >= _this.obj.refreshHeight[_this.obj.activeTab]) {
						// 			_this.obj.lazyRefresh[num].css(_this.obj.refreshingCSS).html(_this.obj.refreshingHtml);
						// 			_this.obj.refreshJudge[num] = true;
						// 			_this.ajax(num, _this.obj.startNum[num]);
						// 		}

						// 		_this.obj.tmpY[_this.obj.activeTab] = 0;
						// 		_this.obj.moveY[_this.obj.activeTab] = 0;
						// 		_this.obj.preMoveY[_this.obj.activeTab] = 0;
								
						// 		(_this.obj.topJudge[num] && _this.obj.firstDirection[num]) && _this.resetIScroll(num);

						// 		_this.obj.con[num].off('touchmove', refresh);
						// 		_this.obj.con[num].off('touchmove', lazyLoading);
						// 	}
						// }(i));

						// this.obj.iScroll[i].on('scroll', lazyLoading);

						// this.obj.iScroll[i].on('scrollEnd', function (num) {
						// 	return function () {
						// 		_this.obj.firstTouch[_this.obj.activeTab] = true;
						// 		if (_this.obj.lazyJudge[num]) {
						// 			_this.obj.lazyLoading[num].css(_this.obj.loadingCSS).html(_this.obj.loadingHtml);
						// 			_this.ajax(num);
						// 		}
						// 	}
						// }(i));
					}
				}

				this.obj.success && this.obj.success();

				if (this.obj.url) {
					this.ajax((obj.startTab && obj.startTab) || 0);		// 当函数被实例化时，先运行加载数据的函数，保证tab切换内容区有内容
				}
			} else {
				this.obj.windowHeight = this.obj.win.height();		// 获取window的高度
				this.obj.bodyHeight = this.obj.con.height();		// 存储body的高度
				this.obj.scrollHeight = 0;		// 页面可滚动的距离
				this.obj.addhtml = '';		// 存储添加的结构的变量
				this.obj.scrollRate = this.obj.scrollRate || 0.99;
				
				this.obj.tabJudge = true;		// 将tab切换所用布尔值传入ajax加载函数，判断加载次数，如果是第一次加载，则将加载的布尔值改为false，防止懒加载时，未点击显示的项目也被加载，此参数需要使用数组值传参进行替代
				this.obj.oldScroll = 0;		// 存储上一次滚动条的位置，用于判断滚动方向

				this.obj.win.resize(function () {	// 窗口调整大小时，重新获取窗口的高度
					_this.resizeHeight();
				});

				this.obj.win.on('scroll', function () {
					_this.scrollData();
				});
			}
		};

		Lazy.prototype.tab = function(index, obj){
			if (obj) {
				if (obj.url) {
					this.obj.url[index] = obj.url;
					this.obj.data[index] = obj.data;
					this.obj.lazyLoading[index].css(db).css(this.obj.loadingCSS).html(this.obj.loadingHtml).addClass('lazy-loading-data').removeClass('lazy-invalid-loading lazy-available-loading lazy-no-data');
					this.ajax(index, this.obj.startNum[index]);
				}
			} else {
				if (this.obj.num[index] == this.obj.startNum[index]) {
					this.ajax(index);
				}
			}
			this.obj.activeTab = index;
		};

		Lazy.prototype.addEvent = function (i) {
			var _this = this;
			_this.obj.iScroll[i].on('scroll', function () {
				if (!_this.obj.noDataJudge[_this.obj.activeTab]) {
					if (Math.abs(_this.obj.iScroll[_this.obj.activeTab].y) > (_this.obj.scroller[_this.obj.activeTab].height() - _this.obj.win[_this.obj.activeTab].height() - _this.obj.lazyHeight[_this.obj.activeTab])) {
						_this.obj.lazyJudge[_this.obj.activeTab] = true;
						_this.obj.lazyLoading[_this.obj.activeTab].css(_this.obj.availableLoadingCSS).html(_this.obj.availableLoadingHtml).addClass('lazy-available-loading').removeClass('lazy-invalid-loading lazy-loading-data lazy-no-data');
					} else {
						_this.obj.lazyJudge[_this.obj.activeTab] = false;
						_this.obj.lazyLoading[_this.obj.activeTab].css(_this.obj.beforeLoadingCSS).html(_this.obj.beforeLoadingHtml).addClass('lazy-invalid-loading').removeClass('lazy-available-loading lazy-loading-data lazy-no-data');
					}
				}

				if (_this.obj.onScroll) {
					if (typeof _this.obj.onScroll == 'function') {
						_this.obj.onScroll(_this.obj.iScroll[_this.obj.activeTab]);
					} else if ($.isArray(_this.obj.onScroll)) {
						if (_this.obj.onScroll[_this.obj.activeTab]) {
							_this.obj.onScroll[_this.obj.activeTab](_this.obj.iScroll[_this.obj.activeTab]);
						}
					}
				}
			});

			_this.obj.iScroll[i].on('scrollEnd', function (num) {
				return function () {
					if (_this.obj.refresh[num]) {
						if (((((-1 * _this.obj.refreshHeight[num]) < _this.obj.iScroll[num].y) && (_this.obj.iScroll[num].y < 0)) || (((_this.obj.iScroll[num].y == 0) && (!_this.obj.refreshJudge[num])) && !_this.obj.refreshingJudge[num])) && !_this.obj.noDataJudge[num]) {
							_this.obj.iScroll[num].scrollTo(0, -1 * _this.obj.refreshHeight[num], 200);
						}
					}

					if (_this.obj.lazyJudge[num] && !_this.obj.noDataJudge[num]) {
						_this.obj.lazyLoading[num].css(_this.obj.loadingCSS).html(_this.obj.loadingHtml).addClass('lazy-loading-data').removeClass('lazy-available-loading lazy-invalid-loading lazy-no-data');
						if (!_this.obj.isNoData[num]) {
							_this.ajax(num);
						}
					}
				}
			}(i));
		}

		Lazy.prototype.resetIScroll = function (index, callback) {
			var _this = this;
			_this.obj.firstTouch[index] = true;
			_this.obj.iScroll[index].scrollTo(0, 0, 200);
			function animateCon() {
				_this.obj.con[index].animate(core.trfObj('translate(0px, 0px) translateZ(0px)'), 200);
				_this.obj.lazyRefresh[index].animate(core.trfObj('translate(0px, 0px) translateZ(0px)'), 200, function () {
					callback && callback();
				});
			}

			if (_this.obj.isRefreshJudge[_this.obj.activeTab] && !_this.obj.refreshJudge[_this.obj.activeTab]) {
				setTimeout(animateCon, 200);
			} else {
				animateCon();
			}

			_this.obj.isRefreshJudge[_this.obj.activeTab] = false;
			_this.obj.isStartRefreshJudge[_this.obj.activeTab] = true;
		};

		Lazy.prototype.cycle = function(cycle, data, index, dataObj, tmpObj, dataProp, propJudge){
			var _this = this;

			for (var i in cycle) {
				// objProp = i;
				if (i == 'eleFun') {
					propJudge = true;
				}
			}

			if ((_this.obj.num[index] == _this.obj.startNum[index]) && _this.obj.refreshingJudge[index]) {
				_this.obj.con[index].empty();
			}

			if (data[i]) {
				cycle[i].ele = this.obj.con[index];
				window.ajax.cycle(cycle, data);
			} else if (propJudge) {
				dataObj.prop = data;
				tmpObj.prop = cycle;
				tmpObj.prop.ele = _this.obj.con[index];
				window.ajax.cycle(tmpObj, dataObj);
			}
		};

		Lazy.prototype.ajax = function(index, num, callback, beforeLoad){
			if (!this.obj.ajaxing[index]) {
				var _this = this;
				this.obj.ajaxing[index] = true;
				(num == undefined) ? (this.obj.num[index] = this.obj.num[index]) : (this.obj.num[index] = num);
				this.obj.loading[index] = true;

				if (this.obj.tabJudge[index]) {		// 使用变量判断是否选中当前内容，如果是则加载，当第一次加载时，该函数的结果都为true
					if (typeof this.obj.url == 'function') {
						var ajaxUrl = this.obj.url(_this.obj.num[index]);
					} else if ($.isArray(this.obj.url)) {
						if (typeof _this.obj.url[index] == 'function') {
							var ajaxUrl = _this.obj.url[index](_this.obj.num[index]);
						} else if (typeof _this.obj.url[index] == 'string') {
							var ajaxUrl = _this.obj.url[index] + _this.obj.num[index];
						}
					}

					if (this.obj.loadingType) {
						this.obj.refreshJudge[index] = false;
						this.obj.refreshingJudge[index] = true;
					}

					_this.obj.noData[index] && ((_this.obj.noData[index].css('display') == 'block') && _this.obj.noData[index].css(dn));

					$.ajax({
						type: _this.obj.type || 'get',
						dataType: _this.obj.dataType || 'json',
						data: ((_this.obj.type == 'post') ? (_this.obj.data[index] ? _this.obj.data[index](_this.obj.num[index]) : undefined) : undefined),
						url: ajaxUrl,		// 利用链接发送加载的编号
						success: function (data) {
							beforeLoad && beforeLoad();
							var objProp = '',
								dataProp = '',
								propJudge = '',
								tmpObj = {},
								dataObj = {};

							_this.obj.ajaxing[index] = false;

							// _this.obj.noData[index] && (!((_this.obj.prop && (data[_this.obj.prop].length == 0)) || (data.length == 0)) && (_this.obj.noData[index].css('display') == 'block') && _this.obj.noData[index].css(dn));

							if (_this.obj.cycle) {
								if ($.isPlainObject(_this.obj.cycle)) {
									_this.cycle(_this.obj.cycle, data, index, dataObj, tmpObj, dataProp, propJudge);
								} else if ($.isArray(_this.obj.cycle)) {
									_this.cycle(_this.obj.cycle[index], data, index, dataObj, tmpObj, dataProp, propJudge);
								}
							}

							if (_this.obj.levelCycle) {
								if (_this.obj.num[index] == _this.obj.startNum[index]) {
									window.ajax.levelCycle(_this.obj.levelCycle, data, true);
								} else {
									window.ajax.levelCycle(_this.obj.levelCycle, data);
								}
							}
							
							// 将添加数据后的结构添加到页面中
							if (_this.obj.device) {
								if (_this.obj.loadingType == 1) {
									if (_this.obj.refreshingJudge[index]) {
										_this.obj.init && _this.obj.init(data, index);
										_this.obj.refreshingJudge[index] = false;

										_this.obj.refresh[index] && _this.obj.lazyRefresh[index].css(_this.obj.beforeRefreshCSS).html(_this.obj.beforeRefreshHtml).addClass('lazy-invalid-refresh').removeClass('lazy-available-refresh refreshing');
									}
								} else {
									if (_this.obj.refreshJudge[index]) {
										_this.resetIScroll(index);
										_this.obj.iScroll[index].refresh(function () {
											_this.obj.lazyRefresh[index].css(_this.obj.beforeRefreshCSS).html(_this.obj.beforeRefreshHtml).addClass('lazy-invalid-refresh').removeClass('lazy-available-refresh lazy-refreshing');
										});
										_this.obj.lazyLoading[index].css(db).css(_this.obj.beforeLoadingCSS).html(_this.obj.beforeLoadingHtml).addClass('lazy-invalid-loading').removeClass('lazy-available-loading lazy-loading-data lazy-no-data');
										_this.obj.refreshJudge[index] = false;
									}
								}

								if (_this.obj.lazyJudge[index]) {
									_this.obj.lazyJudge[index] = false;
									_this.obj.lazyLoading[index].css(db).css(_this.obj.beforeLoadingCSS).html(_this.obj.beforeLoadingHtml).addClass('lazy-invalid-loading').removeClass('lazy-available-loading lazy-loading-data lazy-no-data');
									_this.obj.refresh[index] && _this.obj.lazyRefresh[index].css(_this.obj.beforeRefreshCSS).html(_this.obj.beforeRefreshHtml).addClass('lazy-invalid-refresh').removeClass('lazy-available-refresh lazy-refreshing');
								}

								if ((_this.obj.prop && (data[_this.obj.prop].length == 0)) || (data.length == 0)) {
									_this.obj.noDataJudge[index] = true;
									_this.obj.isNoData[index] = true;
									_this.obj.lazyLoading[index].css(db).css(_this.obj.noLoadingDataCSS).html(_this.obj.noLoadingDataHtml).addClass('lazy-no-data').removeClass('lazy-available-loading lazy-loading-data lazy-invalid-loading');
									setTimeout(function () {
										_this.obj.lazyLoading[index].css(dn);
										_this.obj.noData[index] && ((_this.obj.num[index] == _this.obj.startNum[index]) && _this.obj.noData[index].css(db));
										if ((_this.obj.scroller[index].height() - _this.obj.refreshHeight - _this.obj.lazyHeight) < _this.obj.winHeight[index]) {
											if (_this.obj.refresh[index]) {
												_this.obj.lazyRefresh[index].css(dn);
												_this.obj.iScroll[index].refresh();
											}
										} else {
											_this.obj.noDataJudge[index] = false;
										}
									}, _this.obj.showNoDataTime);
								} else {
									_this.obj.noDataJudge[index] = false;
									_this.obj.isNoData[index] = false;
									_this.obj.num[index]++;
								}

								// if (_this.obj.scroller[index].height() > _this.obj.iScroll[index].wrapperHeight) {
								// }

								!_this.obj.refresh[index] && (!_this.obj.noDataJudge[index] && (((_this.obj.num[index] - 1) == _this.obj.startNum[index]) && _this.obj.iScroll[index].scrollTo(0, 0, 200)));
								_this.obj.refresh[index] && (((_this.obj.num[index] - 1) == _this.obj.startNum[index]) && _this.obj.iScroll[index].scrollTo(0, -1 * _this.obj.refreshHeight[index], 200));

								if ((_this.obj.num[index] == _this.obj.startNum[index]) && _this.obj.noDataJudge[index]) {
									_this.obj.scroller[index].animate({
										transform: 'translate(0px, ' + -1 * _this.obj.refreshHeight[index] + 'px) translateZ(0px)'
									}, 200);
								}

								if ((_this.obj.scroller[index].height() < _this.obj.winHeight[index] + _this.obj.lazyHeight[index] + (_this.obj.refreshHeight[index] || 0)) && ((_this.obj.prop && (data[_this.obj.prop].length != 0)) || (data.length && (data.length != 0)))) {
									_this.ajax(index, undefined, function (index) {
										_this.obj.refresh[index] && _this.obj.iScroll[index].scrollTo(0, -1 * _this.obj.refreshHeight[index], 0);
									});
								}

								_this.obj.iScroll[index].refresh();
								
								_this.obj.callback && _this.obj.callback(data, index, num);
								callback && callback(index);
							} else {
								_this.obj.windowHeight = _this.obj.win.height();		// 获取窗口高度
								_this.obj.bodyHeight = $('body').height();		// 获取页面高度，防止页面加载后，高度变化导致滚动高度比例计算错误
								_this.obj.scrollHeight = _this.obj.windowHeight - (_this.obj.windowHeight * _this.obj.windowHeight) / _this.obj.bodyHeight;		// 计算页面可滚动的距离
							}

							if (_this.obj.loadingType == 1) {

							} else {
								if (Math.abs(_this.obj.iScroll[_this.obj.activeTab].y) > (_this.obj.scroller[_this.obj.activeTab].height() - _this.obj.win[_this.obj.activeTab].height() - _this.obj.lazyHeight[_this.obj.activeTab])) {
									_this.obj.lazyJudge[_this.obj.activeTab] = true;
									_this.obj.lazyLoading[_this.obj.activeTab].css(_this.obj.availableLoadingCSS).html(_this.obj.availableLoadingHtml).addClass('lazy-available-loading').removeClass('lazy-no-data lazy-loading-data lazy-invalid-loading');
								} else {
									_this.obj.lazyJudge[_this.obj.activeTab] = false;
									_this.obj.lazyLoading[_this.obj.activeTab].css(_this.obj.beforeLoadingCSS).html(_this.obj.beforeLoadingHtml).addClass('lazy-invalid-loading').removeClass('lazy-no-data lazy-loading-data lazy-available-loading');
								}
								if (_this.obj.lazyJudge[index]) {
									_this.obj.lazyLoading[index].css(_this.obj.loadingCSS).html(_this.obj.loadingHtml).addClass('lazy-loading-data').removeClass('lazy-no-data lazy-invalid-loading lazy-available-loading');
									_this.ajax(index);
								}
							}
							
							if (data.length == 0) {
								_this.obj.loadJudge = false;		// 变更判断是否加载中的变量为true，表示数据已经加载完成
							} else {
								_this.obj.loadJudge = true;		// 变更判断是否加载中的变量为true，表示数据已经加载完成
							}

							_this.obj.pageLoading && $('#pageLoading').css(dn);

							// this.loading = false;

							// _this.obj.callback && _this.obj.callback(_this.obj.list);		// 如果回调函数存在，则执行，并将当前加载数据的标签传入函数
						}
					});
				}
			}
		};

		Lazy.prototype.resizeHeight = function () {	// 窗口调整大小时，重新获取窗口的高度
			this.obj.windowHeight = this.win.height();		// 获取窗口高度，防止因窗口大小变化导致页面滚动高度比例计算错误
			this.obj.bodyHeight = this.obj.con.height();		// 获取窗口高度，防止因页面高度变化导致页面滚动高度比例计算错误
			this.obj.scrollHeight = this.obj.bodyHeight - this.windowHeight;		// 获取可滚动的高度，防止因窗口大小变化导致页面滚动高度比例计算错误
		};

		Lazy.prototype.scrollData = function () {
			if (this.obj.type == 'pc') {
				var nowScroll = this.win.scrollTop();		// 获取当前滚动的位置
				this.scrollHeight = this.bodyHeight - this.windowHeight;		// 获取可滚动的高度，防止页面滚动高度比例计算错误
				if ((nowScroll > this.scrollHeight * this.scrollRate) && (nowScroll > this.oldScroll) && this.loadJudge && this.tabJudge) {		// 如果页面滚动距离超过设定比例，且之前的Ajax请求已经处理完成，则开始加载。	同时需要满足当前滚动位置大雨上一次滚动的位置，即页面为向下鼓动
					this.loadJudge = false;		// 变更判断是否加载中的变量为true，表示数据已经加载完成
					this.ajax();		// 通过ajax请求数据
				}
				this.oldScroll = nowScroll;		// 存储当前滚动的位置，以便下一次滚动时判断
			} else {

			}
		};

		Lazy.prototype.ajaxJudge = function(judge){		// 函数运行结果为将判断当前内容是否可以加载的变量，返回到ajax加载函数中，该函数在继承之后需要重写，变更返回值为定义的数组
			this.obj.tabJudge = judge;
		};
		
		window.ajax = new Ajax();
		if ($.isPlainObject(obj)) {
			window.ajax.load(obj);
		}
	}

	/*
	 * 1
	 * [ajax 使用Ajax获取后台数据并填写到相应标签中，获取的后台数据是以对象形式传输]
	 * @param  {[对象]} eleObj [传入的对象，其中定义需要传入数据的标签]
	 * @param  {[字符串]} loadUrl [传入的字符串，其中定义获取数据的链接]
	 * @param  {[字符串]} passData [传入的字符串，其中定义通过post传给url的数据]
	 * @param  {[函数]} responseFun [传入的函数，其中定义回调执行的函数]
	 * @param  {[对象]} responseObj [传入的对象，其中定义回调执行的参数]
	 * @param  {[数组]} responseArr [传入的数组，其中定义回调执行的参数]
	 * @date 2016.07.09
	 * @auther Lee Chen
	 * demo 
		var $dataEle = $('.content ul li');
		var elemObj = new (function () {
			this.id = $dataEle.eq(0);
			this.username = $dataEle.eq(1);
		})
		loadHtmlEleData(elemObj, 'inputdata.php');
	 */
	
	function ajaxData(obj) {
		obj.postData = obj.postData || '';
		obj.cache = obj.cache || true;
		var $body = $('body');

		if (obj.beforeLoading) {
			obj.beforeLoading();
		}

		if (obj.loading) {		// 显示loading图
			if (isjQuery(obj.loading)) {
				obj.loading.css(db);
			} else {
				$body.append('<div id="pageLoading"></div>');
				var $pageLoading = $('#pageLoading');
				obj.loadingBac = obj.loadingBac || {
					background: '#fff url(../images/loading.gif) center center no-repeat',
					backgroundSize: '1rem 1rem'
				};
				obj.loadingZIndex = obj.loadingZIndex || 98;
				$pageLoading.css({
					position: 'fixed',
					top: 0,
					bottom: 0,
					left: 0,
					right: 0,
					zIndex: obj.loadingZIndex
				});
				$pageLoading.css(obj.loadingBac);
			}
		}

		if (obj.beforeAjax) {
			obj.beforeAjax();
		}

		if (typeof obj.url == 'function') {
			obj.url = obj.url();
		}

		$.ajax({
			type: obj.type,
			dataType: obj.dataType,
			url: obj.url,
			data: obj.postData,
			cache: obj.cache,
			jsonp: obj.jsonp,
			jsonpCallback: obj.jsonpCallback,
			success: function (data, textStatus, jqXHR) {
				if (obj.load) {
					if (typeof obj.load == 'function') {
						if (obj.load(data)) {
							importData();
						}
					} else {
						importData();
					}
				} else if (obj.load == undefined) {
					importData();
				}

				function importData() {
					// 直接导入json对象中的数据
					inputData(obj, data);

					// 如果需要查找的数据在对象中的某个属性之中，则根据相应属性查找数据
					if (obj.prop) {
						for (var i in obj.prop) {
							inputData(obj.prop[i], findProp(i, data));
						}
					}
				}

				if (obj.callback) {
					obj.callback(data);
				}

				if (obj.loading) {		// 隐藏loading图
					if (obj.removeLoading) {
						if (typeof obj.removeLoading == 'function') {
							if (obj.removeLoading(data)) {
								removeLoading();
							}
						}
					} else if (obj.removeLoading == undefined) {
						removeLoading();
					}
				}

				function removeLoading() {
					if (isjQuery(obj.loading)) {
						obj.loading.css(dn);
					} else {
						$pageLoading.css(dn);
					}
				}
			},
			error: function (XMLHttpRequest, textStatus, errorThrown) {
				if (obj.error) {
					obj.error(XMLHttpRequest, textStatus, errorThrown);
				}
			}
		})

	}

	/*
	 * 12
	 * [inputData 将传入的添加数据对象和数据对象的属性进行对比，相同属性代表的标签中填入相应数据]
	 * @param  {[对象]} obj [定义了需要传入数据的标签对应的属性及属性值]
	 * @param  {[对象]} data [需要传入的数据，为json对象]
	 * @date 2016.07.09
	 * @auther Lee Chen
	 * demo 
		inputData(obj, data);
	 */
	function inputData(obj, data) {
		var eleReg = /^ele\d*$/gi;		// 匹配ele+数字的正则

		// 判断对象的属性类型
		function propTypeJudge(object, prop) {
			for (var i in object) {
				if (typeof object[i] == prop) {
					return true;
				}
			}
		}

		// 判断对象的属性名
		function propNameJudge(object, prop) {
			for (var i in object) {
				if (i == prop) {
					return true;
				}
			}
		}

		// 若object存在before和after属性，则将属性值填充到data的前面和后面，并返回
		function addBeforeAfter(object, data) {
			var str = '';
			if (object.before) {		// 如果需要填充在数据之前的字符串存在，则填充
				str = object.before + data;
			} else {		// 如果填充在数据之前的字符串不存在，则直接存储传入数据
				str = data;
			}
			if (object.after) {		// 如果需要填充在数据之后的字符串存在，则填充
				str += object.after;
			}
			return str;
		}

		// 区分传入对象是否jQuery对象后，将对象传入标签，并支持直接传入或在前或后插入字符串
		function eleInput(object, data, type, attr) {
			function dataInput(object, obj, data) {
				if (obj.type == 'html' || type == 'html') {
					object.html(data);
				} else if (obj.type == 'href' || type == 'href') {
					object.attr({
						href: data
					})
				} else if (obj.type == 'src' || type == 'src') {
					object.attr({
						src: data
					})
					var loading = obj.loading || object.loading;
					if (loading) {
						loading.css({
							display: 'block'
						})
						preLoadPic({
							files: [data],
							complete: function () {
								loading.css({
									display: 'none'
								})
							}
						})
					}
				} else if (obj.type == 'attr' || type == 'attr') {
					var attrObj = {};
					if (obj.attr) {
						attrObj[obj.attr] = data;
					} else {
						attrObj[attr] = data;
					}
					object.attr(attrObj);
				}
			}
			if (isjQuery(object)) {
				dataInput(object, object, data)
			} else {
				var str = addBeforeAfter(object, data);
				for (var i in object) {
					if (i.match(eleReg)) {		// 若ele属性存在，则将相应数据传入ele对应的标签中
						if (isjQuery(object[i])) {
							dataInput(object[i], object, str);
						} else {
							eleInput(object[i], data, type);
						}
					}
				}
			}
		}

		// 批量导入数据或结构
		if (obj.html) {
			for (var i in data) {		// 使用for-in语句遍历后台传入的对象属性
				for (var j in obj.html) {		// 使用for-in语句遍历需要获取数据的对象属性
					if (i == j) {		// 如果两个对象的属性相同，则将后台数据传入相应标签
						eleInput(obj.html[j], data[j], 'html');
					}
				}
			}
		}

		// 批量导入href属性
		if (obj.href) {
			for (var m in data) {		// 使用for-in语句遍历后台传入的对象属性
				for (var n in obj.href) {		// 使用for-in语句遍历需要获取数据的对象属性
					if (m == n) {		// 如果两个对象的属性相同，则将后台数据传入相应标签
						if (data[m] == '') {
							eleInput(obj.href[n], obj.href[n].demohref, 'href');
						} else {
							eleInput(obj.href[n], data[m], 'href');
						}
					}
				}
			}
		}

		// 批量导入src属性
		if (obj.src) {
			for (var o in data) {		// 使用for-in语句遍历后台传入的对象属性
				for (var p in obj.src) {		// 使用for-in语句遍历需要获取数据的对象属性
					if (o == p) {		// 如果两个对象的属性相同，则将后台数据传入相应标签
						if (data[o] == '') {
							eleInput(obj.src[p], obj.src[p].demoSrc, 'src');
						} else {
							eleInput(obj.src[p], data[o], 'src');
						}
					}
				}
			}
		}

		// 批量导入自定义属性
		if (obj.attr) {
			for (var q in data) {
				for (var r in obj.attr) {
					if (q == r) {
						if (data[q] == '') {
							eleInput((obj.attr[r], obj.attr[r].demoAttr, 'attr'), r);
						} else {
							eleInput(obj.attr[r], data[q], 'attr', r);
						}
					}
				}
			}
		}

		if (obj.bgz) {
			addBgz(obj.bgz, data);
		}
		function addBgz(object, data) {
			for (var i in data) {
				for (var j in object) {
					if (i == j) {
						object[j].ele.css({
							background: 'url(' + data[j] + ') 0px 0px no-repeat',
							'-webkit-background-size': '100% 100%',
							'-moz-background-size': '100% 100%',
							'-ms-background-size': '100% 100%',
							'-o-background-size': '100% 100%',
							'background-size': '100% 100%'
						})
					}
				}
			}
		}

		if (obj.bgc) {
			addBgc(obj.bgc, data);
		}
		function addBgc(object, data) {
			for (var i in data) {
				for (var j in object) {
					if (i == j) {
						object[j].ele.css({
							background: 'url(' + data[j] + ') 0 0 no-repeat',
							'-webkit-background-size': 'contain',
							'-moz-background-size': 'contain',
							'-ms-background-size': 'contain',
							'-o-background-size': 'contain',
							'background-size': 'contain'
						})
					}
				}
			}
		}

		if (obj.bg) {
			addBg(obj.bg, data);
		}
		function addBg(object, data) {
			for (var i in data) {
				for (var j in object) {
					if (i == j) {
						var bg = object[j].bg || '0 0 no-repeat';
						object[j].ele.css({
							background: 'url(' + data[j] + ')' + bg,
							'-webkit-background-size': object[j].bgz,
							'-moz-background-size': object[j].bgz,
							'-ms-background-size': object[j].bgz,
							'-o-background-size': object[j].bgz,
							'background-size': object[j].bgz
						})
					}
				}
			}
		}

		// 批量导入相同结构的数据
		if (obj.cycle) {
			cycleInput(obj.cycle, data)
		}

		// 批量导入相同结构的数据
		function cycleInput(object, data) {
			for (var i in data) {
				for (var j in object) {
					if (i == j) {		// 遍历对象的属性，但cycle对象中的属性与data中属性相同时，则传入数据
						eleTypeJudge(object[j], data[j]);
					}
				}
			}
		}

		// 判断ele属性存储数据是否为jQuery对象，如果是则直接导入数据，如果不是则提取其内部的ele属性导入数据
		function eleTypeJudge(object, data) {
			for (var k in object) {
				if (k.match(eleReg)) {		// 如果属性为ele+数字，则表示该属性需要导入数据
					if (isjQuery(object[k])) {		// 判断是否为jQuery对象
						cycleHtml(object, object[k], data, object.eleFun, object.num, object.group, object.cycle, object.lenEle, object.active, object.noData, object.loading);
					} else if (typeof object[k] == 'function') {		// 如果需要动态获取标签，则ele属性以函数形式传入，此时通过运行函数获取标签之后传入数据
						cycleHtml(object, object[k](), data, object.eleFun, object.num, object.group, object.cycle, object.lenEle, object.active, object.noData, object.loading);
					} else {		// 如果不是jQuery对象
						for (var l in object[k]) {
							if (l.match(eleReg)) {		// 提取其中存储jQuery对象的属性，导入数据
								cycleHtml(object[k], object[k][l], data, object.eleFun, object.num, object.group, object.cycle, object.lenEle, object.active, object.noData, object.loading);
							}
						}
					}
				}
			}
		}

		// 批量导入结构
		function cycleHtml(object, element, data, eleFun, num, group, cycle, lenEle, active, noData, loading) {
			var dataLen = data.length;
			object.addHtml = '';

			eleFun = object.eleFun || eleFun;
			if (!$.isArray(object.noData)) {
				noData = object.noData || noData;		// 设定无数据时显示的元素
			}
			
			if (dataLen == 0) {		// 若无数据且无数据显示元素存在，则显示
				if (noData) {
					noData.css({
						display: 'block'
					})
				}
			} else {
				if (noData) {		// 有数据时，将无数据显示元素隐藏
					noData.css(dn)
				}

				if (typeof element == 'function') {
					element = element();
				}
				group = object.group || group;
				cycle = object.cycle || cycle;
				num = object.num || num;
				loading = object.loading || loading;
				
				if (loading) {
					var preloadArr = [];
				}
					
				for (var i = 0; i < dataLen; i++) {
					if (object.demoSrc) {		// 如果demoSrc属性存在且为空或未定义，则用demoSrc的src属性中的地址替换
						for (var j in data[i]) {
							if (j == object.demoSrc.prop) {		// 选取demoSrc中的prop属性所对应的属性，即src地址的属性
								if (data[i][j] == undefined || data[i][j] == '') {		// 如果为空，则使用src属性中的值替换
									data[i][j] = object.demoSrc.src;
								}
							}
						}
					}
					object.addHtml = eleFun(data[i], i, dataLen);
					
					element.append(object.addHtml);

					if (group) {
						groupInput(group, data[i], element.children().last());
					}

					if (cycle) {
						cycleInput(cycle, data[i]);
					}

					if (num - 1 == i) {		// 达到最大显示数量时，则停止循环
						break;
					}

					if (loading) {		// 将加载中的src存入数组
						if (loading.src) {
							preloadArr.push(data[i][loading.src]);
						} else {
							preloadArr.push(data[i]);
						}
					}
				}

				// 实现图片预加载后回调
				if (loading) {
					element.find(loading.ele).css({		// 将所有的加载中元素都显示
						display: 'block'
					})
					preLoadPic({
						files: preloadArr, // 加载的图片存储在数组中
						progress: function(precent, currentImg, index) { // 每加载完成一张图片回调
							element.find(loading.ele).eq(index).css({		// 当一张图片加载完成之后，将相应的加载中元素隐藏
								display: 'none'
							})
						},
					})
				}

				object.addHtml = undefined;		// 清除addHtml在内存中的数据

				lenEle = object.lenEle || lenEle;
				if (lenEle) {		// 如果需要存储分组数量的标签数组存在
					if (isjQuery(lenEle)) {		// 如果存储分组数量的标签值为jQuery对象
						lenEle.html(dataLen);		// 将存储分组数据的数组长度即数据个数存入标签
					} else {
						for (var k in lenEle) {
							if (k.match(eleReg)) {		// 选取ele+数字的属性，为该属性添加值
								lenEle[k].html(addBeforeAfter(lenEle, dataLen));		// 如果有预设数据前后的值，则填充到数据前后再导入标签
							}
						}
					}
				}

				active = object.active || active;
				if (active) {		// 在循环出的结构中，给特定标签添加类名和CSS属性
					if (active.index || active.index == 0) {		// 通过传入的索引值决定添加类名和CSS属性的标签
						activeCss(active, element, active.index);
					} else if (active.prop) {		// 通过传入的属性值是否与标签属性想等，决定添加类名和CSS属性的标签
						for (var l = 0; l < element.children().length; l++) {
							for (var m in active.prop) {
								if (element.children().eq(l).attr(m) == active.prop[m]) {
									activeCss(active, element, l);
								}
							}
						}
					}
				}
				function activeCss(object, ele, index) {
					if (object.class) {
						ele.children().eq(index).addClass(object.class);
					}
					if (object.css) {
						ele.children().eq(index).css(object.css);
					}
				}
			}
		}

		// 批量分级循环导入数据
		if (obj.levelCycle) {
			levelCycleInput(obj.levelCycle, data)
		}

		function levelCycleInput(object, data) {
			var levelObj = {};		// 定义临时数组存储
			for (var i in data) {
				for (var j in object) {
					if (i == j) {		// 查找出相应需要提取数据的属性
						levelObj[j] = [];
						var levelLen = object[j].level.length;
						for (var m = 0; m < levelLen; m++) {		// 创建一个数组存储
							levelObj[j][m] = [];
						}
						for (var k = 0; k < data[i].length; k++) {		// 获取每个属性中需要循环的每个值所对应的对象
							for (var l in data[i][k]) {		// 遍历每个对象中的属性值
								if (l == object[j].levelProp) {		// 查找到用来分级的属性值
									for (var n = 0; n < levelLen; n++) {		// 遍历等级标准数组
										if (object[j].level[n].match(/-/)) {		// 如果分级标准为1-2类型则执行分级
											var levelArrTmp = object[j].level[n].split('-');		// 提取出分级标准的最小值和最大值
											if (data[i][k][l] >= levelArrTmp[0] && data[i][k][l] <= levelArrTmp[1]) {		// 当分级的值在分级标准的范围内时运行（分级标准为>=和<=）
												levelObj[j][n].push(data[i][k]);		// 将提取出的各等级数据存储在数组中
											}
										} else {
											if (object[j].level[n] == data[i][k][l]) {
												levelObj[j][n].push(data[i][k]);
											}
										}
									}
								}
							}
						}
						for (var n = 0; n < object[j].ele.length; n++) {
							if (object[j].levelLenEle) {		// 如果需要存储分组数量的标签数组存在
								if (isjQuery(object[j].levelLenEle[n])) {		// 如果存储分组数量的标签值为jQuery对象
									object[j].levelLenEle[n].html(levelObj[j][n].length);		// 将存储分组数据的数组长度即数据个数存入标签
								} else {
									for (var o in object[j].levelLenEle[n]) {
										if (o.match(eleReg)) {		// 选取ele+数字的属性，为该属性添加值
											object[j].levelLenEle[n][o].html(addBeforeAfter(object[j].levelLenEle[n], levelObj[j][n].length));		// 如果有预设数据前后的值，则填充到数据前后再导入标签
										}
									}
								}
							}
							// console.log(object[j].noData[n])
							cycleHtml(object[j], object[j].ele[n], levelObj[j][n], object[j].eleFun, object[j].num, object[j].group, object[j].cycle, object[j].lenEle, object[j].active, object[j].noData[n], object[j].loading);
						}
					}
				}
			}
		}

		// 批量分组导入相同结构的数据
		if (obj.group) {
			groupInput(obj.group, data);
		}

		// 批量分组导入结构的数据的函数
		function groupInput(object, data, element) {
			for (var i in data) {
				for (var j in object) {
					if (i == j) {
						object[j].addHtml = '';		// 创建一个存储添加数据的结构的变量
						object[j].parentHtml = '';		// 创建一个存储添加数据分组父级的变量
						object[j].dataLen = data[j].length;		// 存储要添加的数据长度
						object[j].groupLen = Math.ceil(object[j].dataLen / object[j].eleNum);		// 存储数据的组数量
						for (var s = 0; s < object[j].groupLen; s++) {		// 使用for循环批量添加相应组数量的数据父级
							object[j].parentHtml += object[j].groupEle;		// 将数据组父级的结构添加到变量中
						}
						var $groupELe = {};
						if (element) {
							$groupELe = element.find(object[j].ele);
						} else {
							$groupELe = $(object[j].ele);
						}
						$groupELe.html(object[j].parentHtml);		// 添加相应数据组的父级结构
						if (object[j].loading) {
							var preloadArr = [];
						}
						for (var s = 0; s < object[j].dataLen; s++) {
							object[j].addHtml = '';
							if (object[j].loading) {
								if (object[j].loading.src) {
									preloadArr.push(data[j][s][object[j].loading.src]);
								} else {
									preloadArr.push(data[j][s]);
								}
							}
							
							for (var t = 0; t < object[j].eleNum; t++) {
								if (data[j][s * object[j].eleNum + t] != undefined) {
									object[j].addHtml += object[j].eleFun(data[j][s * object[j].eleNum + t]);
								}
							}
							$groupELe.children().eq(s).html(object[j].addHtml);
						}
						// 实现图片预加载后回调
						if (object[j].loading) {
							if (isjQuery(object[j].ele) == undefined) {
								if (typeof object[j].ele == 'string') {
									var objTmp = element.find(object[j].ele);
								} else {
									var objTmp = object[j].ele();
								}
							} else {
								objTmp = object[j].ele
							}
							objTmp.find(object[j].loading.ele).css({		// 将所有的加载中元素都显示
								display: 'block'
							})
							preLoadPic({
								files: preloadArr, // 加载的图片存储在数组中
								progress: function(precent, currentImg, index) { // 每加载完成一张图片回调
									objTmp.find(object[j].loading.ele).eq(index).css({		// 当一张图片加载完成之后，将相应的加载中元素隐藏
										display: 'none'
									})
								},
							});
						}
					}
				}
			}
		}

		// 直接导入结构数据
		if (obj.page) {
			getHtml(obj.page, data);
		}

		// 直接导入结构或者从传入的结构中提取出
		function getHtml(object, data) {
			if (object.getHtml) {
				object.ele.html(getHtml(data, object.getHtml, object.inside));
			} else {
				object.ele.html(data);
			}
		}

		// 从数据中查找某个数据，若存在则提取出，批量导入结构
		if (obj.ifData) {
			ifDataCycle(obj.ifData, data);
		}

		function ifDataCycle(object, data) {
			for (var i in data) {
				for (var j in object){
					if (i == j) {
						if (object[j].array) {
							var dataArr = [];
							for (var k = 0; k < data[i].length; k++) {
								if (data[i][k][object[j].array].length > 0) {
									dataArr.push(data[i][k])
								}
							}

							var dataArrLen = dataArr.length;
							
							if (isjQuery(object[j].lenEle)) {
								object[j].lenEle.html(dataArrLen)
							} else {
								object[j].lenEle.ele.html(addBeforeAfter(object[j].lenEle, dataArrLen));
							}

							if (dataArrLen > 0) {
								cycleHtml(object[j], object[j].ele, dataArr, object[j].eleFun, object[j].num, object[j].group, object[j].cycle, object[j].lenEle, object[j].active, object[j].noData, object[j].loading);
							} else {
								if (object[j].noData) {
									object[j].noData.css({
										display: 'block'
									})
								}
							}
							
						}
					}
				}
			}
		}


	}

	/*
	 * 2
	 * [postLoadHtmlData 使用Ajax获取后台数据并填写到相应标签中，获取的后台数据是以对象形式传输]
	 * @param  {[对象]} eleObj [传入的对象，其中定义需要传入数据的标签]
	 * @param  {[字符串]} loadUrl [传入的字符串，其中定义获取数据的链接]
	 * @param  {[字符串]} passData [传入的字符串，其中定义通过post传给url的数据]
	 * @param  {[函数]} responseFun [传入的函数，其中定义回调执行的函数]
	 * @param  {[对象]} responseObj [传入的对象，其中定义回调执行的参数]
	 * @param  {[数组]} responseArr [传入的数组，其中定义回调执行的参数]
	 * @date 2016.05.19
	 * @auther Lee Chen
	 * demo 
		postLoadHtmlData({
			available_points: $('.roll-out-points-bac .roll-out-points .roll-out-points-confirm form .available-points span'),
			phone: $('.roll-out-points-bac .roll-out-points .roll-out-points-confirm form .phone-number span')
		}, '../get_roll_out_infodata.php', 'id=1', function () {
			hideCenterPhoneNum($('.roll-out-points-bac .roll-out-points .roll-out-points-confirm form .phone-number span'));
		})
	 */

	function postLoadHtmlData(eleObj, loadUrl, passData, responseFun, responseObj, responseArr) {
		if (passData == undefined) {
			passData = '';
		}
		$.ajax({
			type: 'post',
			dataType: 'json',
			url: loadUrl,
			data: passData,
			cache: false,
			success: function (data, textStatus, jqXHR) {
				for (var i in data[0]) {		// 使用for-in语句遍历后台传入的对象属性
					for (var j in eleObj) {		// 使用for-in语句遍历需要获取数据的对象属性
						if (i == j) {		// 如果两个对象的属性相同，则将后台数据传入相应标签
							eleObj[j].html(data[0][i]);
						}
					}
				}
				if (responseFun) {
					responseFun(data[0], responseObj, responseArr);
				}
			}
		})
	}

	/*
	 * 3
	 * [loadHtmlArrData 使用Ajax获取后台数据并填写到相应标签中，获取的后台数据是以数组形式传输]
	 * @param  {[对象]} eleArr [传入的数组，其中定义需要传入数据的标签]
	 * @param  {[字符串]} loadUrl [传入的字符串，其中定义获取数据的链接]
	 * @param  {[字符串]} passData [传入的字符串，其中定义通过post传给url的数据]
	 * @param  {[函数]} responseFun [传入的函数，其中定义回调执行的函数]
	 * @param  {[对象]} responseObj [传入的对象，其中定义回调执行的参数]
	 * @param  {[数组]} responseArr [传入的数组，其中定义回调执行的参数]
	 * @date 2016.05.19
	 * @auther Lee Chen
	 * demo 
		var $dataEle = $('.content ul li');
		var elemArr = [$dataEle.eq(0), $dataEle.eq(1)];
		loadHtmlArrData(elemArr, 'inputdata.php');
	 */

	function loadHtmlArrData(eleArr, loadUrl, passData, responseFun, responseObj, responseArr) {
		$.ajax({
			type: 'get',
			dataType: 'json',
			url: loadUrl,
			cache: false,
			success: function (data) {
				for (var i = 0; i < data.length; i++) {		// 使用for语句遍历后台传入的数组
					eleArr[i].html(data[i]);		// 将对应索引值的后台数据传入相应标签
				}
				if (responseFun) {
					responseFun(responseObj, responseArr, data[0]);
				}
			}
		})
	}

	/*
	 * 4
	 * [loadValEleData 使用Ajax获取后台数据并填写到相应input输入框中，获取的后台数据是以对象形式传输]
	 * @param  {[对象]} eleObj [传入的对象，其中定义需要传入数据的标签]
	 * @param  {[字符串]} loadUrl [传入的字符串，其中定义获取数据的链接]
	 * @param  {[字符串]} passData [传入的字符串，其中定义通过post传给url的数据]
	 * @param  {[函数]} responseFun [传入的函数，其中定义回调执行的函数]
	 * @param  {[对象]} responseObj [传入的对象，其中定义回调执行的参数]
	 * @param  {[数组]} responseArr [传入的数组，其中定义回调执行的参数]
	 * @date 2016.05.19
	 * @auther Lee Chen
	 * demo 
		var $dataEle = $('.content ul li');
		var elemObj = new (function () {
			this.id = $dataEle.eq(0);
			this.username = $dataEle.eq(1);
		})
		loadHtmlEleData(elemObj, 'inputdata.php');
	 */

	function loadValEleData(eleObj, loadUrl, passData, responseFun, responseObj, responseArr) {
		$.ajax({
			type: 'get',
			dataType: 'json',
			url: loadUrl,
			cache: false,
			success: function (data) {
				for (var i in data[0]) {		// 使用for-in语句遍历后台传入的对象属性
					for (var j in eleObj) {		// 使用for-in语句遍历需要获取数据的对象属性
						if (i == j) {		// 如果两个对象的属性相同，则将后台数据传入相应标签
							eleObj[j].val(data[0][i]);
						}
					}
				}
				if (responseFun) {
					responseFun(responseObj, responseArr, data[0]);
				}
			}
		})
	}

	/*
	 * 5
	 * [loadValArrData 使用Ajax获取后台数据并填写到相应input输入框中，获取的后台数据是以数组形式传输]
	 * @param  {[对象]} eleArr [传入的数组，其中定义需要传入数据的标签]
	 * @param  {[字符串]} loadUrl [传入的字符串，其中定义获取数据的链接]
	 * @param  {[字符串]} passData [传入的字符串，其中定义通过post传给url的数据]
	 * @param  {[函数]} responseFun [传入的函数，其中定义回调执行的函数]
	 * @param  {[对象]} responseObj [传入的对象，其中定义回调执行的参数]
	 * @param  {[数组]} responseArr [传入的数组，其中定义回调执行的参数]
	 * @date 2016.05.19
	 * @auther Lee Chen
	 * demo 
		var $dataEle = $('.content ul li');
		var elemArr = [$dataEle.eq(0), $dataEle.eq(1)];
		loadHtmlArrData(elemArr, 'inputdata.php');
	 */

	function loadValArrData(eleArr, loadUrl, passData, responseFun, responseObj, responseArr) {
		$.ajax({
			type: 'get',
			dataType: 'json',
			url: loadUrl,
			cache: false,
			success: function (data) {
				for (var i = 0; i < data.length; i++) {		// 使用for语句遍历后台传入的数组
					eleArr[i].val(data[i]);		// 将对应索引值的后台数据传入相应标签
				}
				if (responseFun) {
					responseFun(responseObj, responseArr, data[0]);
				}
			}
		})
	}

	/*
	 * 6
	 * [loadSrcData 使用Ajax获取后台数据并填写到相应input输入框中，获取的后台数据是以对象形式传输]
	 * @param  {[对象]} eleObj [传入的对象，其中定义需要传入数据的标签]
	 * @param  {[字符串]} loadUrl [传入的字符串，其中定义获取数据的链接]
	 * @param  {[字符串]} demoSrc [传入的字符串，其中定义无src地址时，替代的src地址]
	 * @param  {[字符串]} passData [传入的字符串，其中定义通过post传给url的数据]
	 * @param  {[函数]} responseFun [传入的函数，其中定义回调执行的函数]
	 * @param  {[对象]} responseObj [传入的对象，其中定义回调执行的参数]
	 * @param  {[数组]} responseArr [传入的数组，其中定义回调执行的参数]
	 * @date 2016.05.19
	 * @auther Lee Chen
	 * demo 
		var $dataEle = $('.content ul li');
		var elemObj = new (function () {
			this.id = $dataEle.eq(0);
			this.username = $dataEle.eq(1);
		})
		loadSrcData(elemObj, 'inputdata.php');
	 */

	function loadSrcData(eleObj, loadUrl, demoSrc, passData, responseFun, responseObj, responseArr) {
		$.ajax({
			type: 'get',
			dataType: 'json',
			url: loadUrl,
			cache: false,
			success: function (data) {
				for (var i in data[0]) {		// 使用for-in语句遍历后台传入的对象属性
					for (var j in eleObj) {		// 使用for-in语句遍历需要获取数据的对象属性
						if (i == j) {		// 如果两个对象的属性相同，则将后台数据传入相应标签
							if (data[0][i] == '') {
								eleObj[j].attr({src: demoSrc});
							} else {
								eleObj[j].attr({src: data[0][i]});
							}
						}
					}
				}
				if (responseFun) {
					responseFun(responseObj, responseArr, data[0]);
				}
			}
		})
	}

	/*
	 * 7
	 * [lazyLoadingScroll 使用Ajax获取后台数据实现懒加载效果]
	 * @param  {[字符串]} url [传入的字符串，其中定义获取数据的链接]
	 * @param  {[数字]} scrollRate [传入的字符串，开始加载时滚动条滚动到加载位置时，和页面高度的比例]
	 * @param  {[对象]} parentEle [传入的对象，其中定义需要传入数据的标签]
	 * @param  {[函数]} eleFun [利用函数传入需要加载数据的页面结构]
	 * @param  {[函数]} callback [定义数据加载完成之后运行的函数]
	 * @date 2016.05.20
	 * @auther Lee Chen
	 * demo 
		lazyLoadingScroll({
			url: pageDataUrl,
			parentEle: $('#loves'),
			prop: 'loves.loves_list',
			eleFun: function (data) {
				return '<li>' + 
					'<div class="product-div">' + 
						'<a class="product-div-link" href="' + data.image + '"></a>' + 
						'<img class="product-list-img" src="' + data.image + '" />' + 
						'<div class="product-text">' + 
							'<h4><' + data.name + '></h4>' + 
							'<p><span class="p-price t-first "><' + data.price + '<small></small></span></p>' + 
							'<a href="javascript:void(0)" class="icon-flow-cart fr j-goods-attr"><i class="iconfont icon-gouwuche"></i></a>' + 
						'</div>' + 
					'</div>' + 
				'</li>'
			}
		})
	 */

	function lazyLoadingScroll(obj) {
		var num = obj.startPage || 0;		// 定义加载数据的次数
		var loadJudge = true;		// 定义判断是否在加载中的布尔值
		var $window = $(window);		// 获取window
		var $body = $('body');		// 获取body
		var windowHeight = $window.height();		// 获取window的高度
		var bodyHeight = $body.height();		// 存储body的高度
		var scrollHeight = 0;		// 页面可滚动的距离
		var addHtml = '';		// 存储添加的结构的变量
		var urlType = true;		// 判断url类型的变量
		var ajaxUrl = '';
		var eleLenJudge = true;

		obj.getData = obj.getData || '';
		obj.postData = obj.postData || '';
		obj.type = obj.type || 'get';
		obj.dataType = obj.dataType || 'json';
		obj.cache = obj.cache || false;

		if (typeof obj.url == 'function') {
			urlType = false;
		}

		if (obj.scrollRate == undefined) {
			obj.scrollRate = 0.99;
		}

		if (obj.clear) {		// 可通过设定clear属性为true在第一次懒加载之前清空标签内的内容
			obj.parentEle.html('');
		}

		function ajaxData() {
			if (urlType) {
				ajaxUrl = obj.url + num;
			} else {
				ajaxUrl = obj.url(num);
			}

			if (obj.cache == undefined) {
				obj.cache = true;
			}

			if (obj.imgLoading || eleLenJudge) {
				obj.eleLen = obj.eleLen || obj.parentEle.children().length;
				eleLenJudge = false;
			}

			if (obj.loading) {
				obj.loading.css({
					display: 'block'
				})
			}

			$.ajax({
				type: obj.type,
				dataType: obj.dataType,
				url: ajaxUrl,		// 利用链接发送加载的编号
				data: obj.postData,
				cache: obj.cache,
				success: function (data) {
					addHtml = '';		// 每次加载之前，清空已加载的数据

					if (obj.prop) {		// 如果需要查找的数据在对象中的某个属性之中，则根据相应属性查找数据
						data = findProp(obj.prop, data);
					}
					
					var preloadArr = [];
					var dataLen = data.length;
					var cycleHtml = '';

					function imgLoad(object, data, parentEle,loadingLen) {
						var dataLen = data.length;
						for (var j = 0; j < dataLen; j++) {
							if (object.imgLoading) {
								if (object.imgLoading.src) {
									preloadArr.push(data[j][object.imgLoading.src]);
								} else {
									preloadArr.push(data[j]);
								}
								// 为保证懒加载时图片加载中提示能找到相应元素，需要加上现有的元素数量
								parentEle.find(object.imgLoading.ele).eq(loadingLen + j).css({
									display: 'block'
								})
							}
						}

						// 实现图片预加载后回调
						if (object.imgLoading) {
							preLoadPic({
								files: preloadArr, // 加载的图片存储在数组中
								progress: function(precent, currentImg, index) { // 每加载完成一张图片回调
									// 当一张图片加载完成之后，将相应的加载中元素隐藏
									parentEle.find(object.imgLoading.ele).eq(loadingLen + index).css({
										display: 'none'
									})
								},
							})
						}
					}
					if (obj.imgLoading) {
						imgLoad(obj, data, obj.parentEle, obj.parentEle.find(obj.imgLoading.ele).length);
					}

					for (var i = 0; i < dataLen; i++) {		// 使用for循环加载数据到
						addHtml += obj.eleFun(data[i]);

						obj.parentEle.append(addHtml);		// 将添加数据后的结构添加到页面中

						addHtml = '';
						if (obj.cycle) {
							for (var k in data[i]) {
								for (var l in obj.cycle) {
									if (l == k) {
										if (typeof obj.cycle[l].ele == 'function') {
											var ele = obj.cycle[l].ele();
										} else {
											var ele = obj.cycle[l].ele;
										}

										if (obj.cycle[l].imgLoading) {		// 获取现有的loading元素长度
											var loadLen = obj.parentEle.find(obj.cycle[l].imgLoading.ele).length;
										}

										for (var m = 0; m < data[i][k].length; m++) {
											cycleHtml += obj.cycle[l].eleFun(data[i][k][m]);
										}
										ele.append(cycleHtml);
										cycleHtml = '';

										if (obj.cycle[l].imgLoading) {
											imgLoad(obj.cycle[l], data[i][k], obj.parentEle, loadLen);
										}
									}
								}
							}
						}
					}

					windowHeight = $window.height();		// 获取窗口高度
					bodyHeight = $('body').height();		// 获取页面高度，防止页面加载后，高度变化导致滚动高度比例计算错误
					scrollHeight = windowHeight - (windowHeight * windowHeight) / bodyHeight;		// 计算页面可滚动的距离
					if (data.length == 0) {		// 如果加载的数据为空值时，不再加载数据
						loadJudge = false;
						if (obj.noData) {
							obj.noData.css({
								display: 'block'
							})
						}
					} else {
						loadJudge = true;
					}
					if (obj.callback) {
						obj.callback();
					}

					if (obj.loading) {
						obj.loading.css({
							display: 'none'
						})
					}
				}
			});
		}

		if (obj.preload == true || obj.preload == undefined) {		// 若需要页面载入时就加载数据则设置preload为true
			ajaxData();
		}

		$window.resize(function () {	// 窗口调整大小时，重新获取窗口的高度
			windowHeight = $window.height();		// 获取窗口高度，防止因窗口大小变化导致页面滚动高度比例计算错误
			bodyHeight = $body.height();		// 获取窗口高度，防止因页面高度变化导致页面滚动高度比例计算错误
			scrollHeight = bodyHeight - windowHeight;		// 获取可滚动的高度，防止因窗口大小变化导致页面滚动高度比例计算错误
		})

		if (obj.removeScroll) {		// 清除原有滚动事件
			$window.off('scroll');
		}

		$window.on('scroll', scrollLoading);

		function scrollLoading() {
			scrollHeight = bodyHeight - windowHeight;		// 获取可滚动的高度，防止页面滚动高度比例计算错误
			if (($window.scrollTop() > scrollHeight * obj.scrollRate) && loadJudge) {		//当页面滚动距离超过设定比例，且之前的Ajax请求已经处理完成，则开始加载
				loadJudge = false;		// 加载时将布尔值设置为false，防止滚动时进行多次加载
				num++;		// 加载数据的值加1，保证下次加载时，加载下一段数据
				ajaxData();
			}
		}
	}

	/*
	 * 8
	 * [lazyLoadingClick 使用Ajax获取后台数据实现懒加载效果]
	 * @param  {[字符串]} loadUrl [传入的字符串，其中定义获取数据的链接]
	 * @param  {[对象]} loadBtn [传入的对象，其中定义点击加载数据的按钮]
	 * @param  {[对象]} getDataEle [传入的对象，其中定义需要传入数据的标签]
	 * @param  {[函数]} htmlFun [利用函数传入需要加载数据的页面结构]
	 * @param  {[函数]} callbackFun [定义数据加载完成之后运行的函数]
	 * @date 2016.05.20
	 * @auther Lee Chen
	 * demo 
		lazyLoadingClick('pointdetail.php?point_index=', 0.95, $('.point-detail'), pointStr);
	 */

	function lazyLoadingClick(loadUrl, loadBtn, getDataEle, htmlFun, callbackFun) {
		var num = 0;		// 定义加载数据的次数
		var loadJudge = true;		// 定义判断是否在加载中的布尔值
		var addhtml = '';		// 存储添加的结构的变量

		function ajaxData() {
			$.ajax({
				type: 'get',
				dataType: 'json',
				url: loadUrl + num,		// 利用链接发送加载的编号
				success: function (data) {
					addhtml = '';		// 每次加载之前，清空已加载的数据
					for (var i = 0; i < data.length; i++) {		// 使用for循环加载数据到
						addhtml += htmlFun(data[i]);
					}
					getDataEle.append(addhtml);		// 将添加数据后的结构添加到页面中
					if (data.length == 0) {		// 如果加载的数据为空值时，不再加载数据
						loadJudge = false;
					} else {
						loadJudge = true;
					}
					if (callbackFun) {
						callbackFun();
					}
				}
			});
		}ajaxData();

		loadBtn.on('click', function () {
			if (loadJudge) {		//当页面滚动距离超过设定比例，且之前的Ajax请求已经处理完成，则开始加载
				loadJudge = false;		// 加载时将布尔值设置为false，防止滚动时进行多次加载
				num++;		// 加载数据的值加1，保证下次加载时，加载下一段数据
				ajaxData();
			}
		})
	}

	/*
	 * 9
	 * [LazyLoadingScroll 使用面向对象，Ajax获取后台数据,结合animateCore库中的tabSwitch函数，实现tab切换加懒加载效果，IE中有bug]
	 * @param  {[对象]} loadingObj [定义传入参数的对象]
	 * @date 2016.06.14
	 * @auther Lee Chen
	 * demo 
		// tab切换 + 通过滚动的懒加载
		var urlArray = ['../card_buy.php?card_buy=', '../pointdetail.php?point_index=', '../pre_record.php?pre_index=', '../roll_out.php?roll_index=', '../income_record.php?income_index='];
		var eleArray = [$('.card-record tbody'), $('.point-detail tbody'), $('.pre-record tbody'), $('.roll-out tbody'), $('.income-record tbody')];
		var htmlArray = [function cardStr(data) {
			return '<tr>' + 
				'<td class="nowtime">' + data.time +  '</td>' + 
				'<td class="order">' + data.order + '</td>' + 
				'<td class="money">' + data.money + '</td>' + 
				'<td class="number">' + data.number + '</td>' + 
				'<td class="operation">' + 
					'<a href="" title="">退单</a>' + 
				'</td>' + 
			'</tr>'
		}, function pointStr(data) {		// 积分明细
			return '<tr>' + 
				'<td class="nowtime">' + data.time + '</td>' + 		// 创建时间
				'<td class="dividend">' + data.order + '</td>' + 		// 名称
				'<td class="num">' + data.name + '</td>' + 		// 订单号
				'<td>' + data.points + '</td>' + 		// 积分
				'<td>' + data.state + '</td>' + 		// 状态
				'<td class="bonus">' + data.remark + '</td>' + 		// 备注
			'</tr>';
		}, function PreStr(data) {		// 预购纪录
			return '<tr>' + 
				'<td class="nowtime">' + data.time + '</td>' + 		// 创建时间
				'<td class="order">' + data.order + '</td>' + 		// 订单号	
				'<td class="money">' + data.money + '</td>' + 		// 金额（元）
				'<td class="number">' + data.income + '</td>' + 		// 数量
				'<td class="operation">' + 
					'<a href="" title="退单">退单</a>' + 
				'</td>' + 
			'</tr>';
		}, function rollStr(data) {		// 转出记录
			return '<tr>' + 
				'<td class="nowtime">' + data.time + '</td>' + 		// 创建时间
				'<td class="num">' + data.number + '</td>' + 		// 交易号
				'<td>' + data.point + '</td>' + 		// 	积分
				'<td>' + data.status + '</td>' + 		// 	状态
				'<td class="bonus">' + data.remark + '</td>' + 		// 备注
			'</tr>';
		}, function incomeStr(data) {		// 收益记录
			return '<tr>' + 
				'<td class="nowtime">' + data.time + '</td>' + 		// 创建时间
				'<td class="num">' + data.number + '</td>' + 		// 订单号
				'<td class="dividend">' + data.name + '</td>' + 		// 名称
				'<td>' + data.point + '</td>' + 		// 积分
				'<td>' + data.status + '</td>' + 		// 状态
				'<td class="bonus">' + data.remark + '</td>' + 		// 备注
			'</tr>';
		}];
		var ajaxJudgeArr = [true, false, false, false, false];		// 设定数组存储每个按钮的布尔值

		var funArr = [];
		function createTabLazyLoading(urlArr, eleArr, htmlArr, judgeArr, rate, callback) {
			for (var i = 0; i < urlArr.length; i++) {
				function AjaxTab() {		// 使用集成实例化收益记录
					LazyLoadingScroll.call(this, {
						loadUrl: urlArr[i],
						scrollRate: rate, 
						getDataEle: eleArr[i],
						htmlFun: htmlArr[i],
						callbackFun: callback,
						firstLoadJudge: ajaxJudgeArr[i],
						loadingHint: $('.loading')
					});
				}

				for (var j in LazyLoadingScroll.prototype) {		// 使用for-in继承方法
					AjaxTab.prototype[j] = LazyLoadingScroll.prototype[j];
				}

				funArr[i] = new AjaxTab();
			}
		}

		createTabLazyLoading(urlArray, eleArray, htmlArray, ajaxJudgeArr, 0.95, function ($this) {		// 回调函数，处理积分正负时显示不同颜色
			caseStyle($('.point-detail tbody tr td:nth-child(4), .pre-record tbody tr td:nth-child(3), .roll-out tbody tr td:nth-child(3), .income-record tbody tr td:nth-child(4)'), 'add', 'add', 'reduce');
			intervalClass({
				'changeEle': $this.children(),
				'judge': false,
				'classN': 'even-color'
			});
		});

		var firstClickJudge = [false, true, true, true, true];		// 存储判断是否第一次点击选项卡的布尔值，第一次点击时加载数据

		function changeAjaxJudge(i, $this) {		// tab切换时，点击切换按钮，改变每个按钮的布尔值，布尔值为true时，对应的表格为可进行ajax加载
			var $selectCover = $('.points-mine .points-detail .select-cover')
			$selectCover.css({
				'left': $this.position().left - 1 + 'px'
			});
			thisIndex = $this.index();
			$selectCover.html($this.html());

			for (var j = 0; j < ajaxJudgeArr.length; j++) {		// 将控制所有的选项卡是否可加载的布尔值改为false，为不可加载状态
				ajaxJudgeArr[j] = false;
			}
			ajaxJudgeArr[i] = true;		// 将点击的选项卡是否可加载的布尔值改为true，转换为可加载状态

			for (var j = 0; j < ajaxJudgeArr.length; j++) {		// 每次点击时，将控制每个选项卡是否可加载的布尔值，通过ajaxJudge方法传入对象中
				funArr[j].ajaxJudge(ajaxJudgeArr[j]);
			}

			if (firstClickJudge[i]) {		// 如果是第一次加载数据，则加载
				funArr[i].ajaxData();		// 加载数据
				firstClickJudge[i] = false;		// 加载完成之后，将布尔值改为false，下次tab切换时不会再加载数据
			}
		}

		tabSwitch({
			'tabTit': $('.points-detail .points-tit span'),		// 传入tab切换标题
			'tabCon': $('.points-detail .points-con table'),		// 传入tab切换内容
			'titClass': 'select-tit',		// 传入标题点击时加入的类名
			'conClass': 'select-con'		// 传入内容显示时加入的类名
		}, changeAjaxJudge);		// 传入函数，点击时同步改变判断ajax加载的布尔值，点击的按钮为true，即可以加载该部分内容，其他内容为false，不可加载

	 */
	function LazyLoadingScroll(loadingObj) {
		var _this = this;		// 定义变量存储当前this指向，以便在事件中调用使用
		this.num = 0;		// 定义加载数据的次数
		this.loadJudge = true;		// 定义判断是否在加载中的布尔值
		this.$window = $(window);		// 获取window的高度
		this.$body = $('body');		// 获取body
		this.windowHeight = this.$window.height();		// 获取window的高度
		this.bodyHeight = this.$body.height();		// 存储body的高度
		this.scrollHeight = 0;		// 页面可滚动的距离
		this.addhtml = '';		// 存储添加的结构的变量
		this.loadUrl = loadingObj.loadUrl;		// 存储获取数据的链接
		if (loadingObj.scrollRate) {
			this.scrollRate = loadingObj.scrollRate;		// 开始加载时滚动条滚动到加载位置时，和页面高度的比例
		} else {
			this.scrollRate = 0.99;		// 默认的启动加载滚动条位置为95%
		}
		
		this.getDataEle = loadingObj.getDataEle;		// 存储需要传入数据的标签
		this.loadingHint = loadingObj.loadingHint;		// 存储加载数据时提示的标签
		this.htmlFun = loadingObj.htmlFun;		// 利用函数传入需要加载数据的页面结构
		this.tabJudge = true;		// 将tab切换所用布尔值传入ajax加载函数，判断加载次数，如果是第一次加载，则将加载的布尔值改为false，防止懒加载时，未点击显示的项目也被加载，此参数需要使用数组值传参进行替代
		this.oldScroll = 0;		// 存储上一次滚动条的位置，用于判断滚动方向
		this.callbackFun = loadingObj.callbackFun;		// 定义数据加载完成之后运行的函数

		this.ajaxJudge(loadingObj.firstLoadJudge);		// 实例化时，先传入控制是否第一次加载的布尔值

		this.ajaxData();		// 当函数被实例化时，先运行加载数据的函数，保证tab切换内容区有内容

		this.$window.resize(function () {	// 窗口调整大小时，重新获取窗口的高度
			_this.resizeHeight();
		})
	}

	LazyLoadingScroll.prototype.ajaxData = function(){
		var _this = this;
		this.loadingHint.css({		// 显示提示加载中的标签
			display: 'block'
		});
		if (this.tabJudge) {		// 使用变量判断是否选中当前内容，如果是则加载，当第一次加载时，该函数的结果都为true
			$.ajax({
				type: 'get',
				dataType: 'json',
				url: _this.loadUrl + _this.num,		// 利用链接发送加载的编号
				success: function (data) {
					_this.addhtml = '';		// 每次加载之前，清空已加载的数据
					for (var i = 0; i < data.length; i++) {		// 使用for循环加载数据到
						_this.addhtml += _this.htmlFun(data[i]);
					}
					_this.loadingHint.css({		// 加载数据时，将提示加载中的标签隐藏
						display: 'none'
					});
					_this.getDataEle.append(_this.addhtml);		// 将添加数据后的结构添加到页面中
					_this.windowHeight = _this.$window.height();		// 获取窗口高度
					_this.bodyHeight = $('body').height();		// 获取页面高度，防止页面加载后，高度变化导致滚动高度比例计算错误
					_this.scrollHeight = _this.windowHeight - (_this.windowHeight * _this.windowHeight) / _this.bodyHeight;		// 计算页面可滚动的距离
					if (data.length == 0) {
						_this.loadJudge = false;		// 变更判断是否加载中的变量为true，表示数据已经加载完成
					} else {
						_this.loadJudge = true;		// 变更判断是否加载中的变量为true，表示数据已经加载完成
					}
					_this.$window.on('scroll', function () {
						_this.scrollData();
					})
					if (_this.callbackFun) {		// 如果回调函数存在，则执行
						_this.callbackFun(_this.getDataEle);		// 将当前加载数据的标签传入函数
					}
				}
			});
			this.num++;
		}
	};

	LazyLoadingScroll.prototype.resizeHeight = function () {	// 窗口调整大小时，重新获取窗口的高度
		this.windowHeight = this.$window.height();		// 获取窗口高度，防止因窗口大小变化导致页面滚动高度比例计算错误
		this.bodyHeight = this.$body.height();		// 获取窗口高度，防止因页面高度变化导致页面滚动高度比例计算错误
		this.scrollHeight = this.bodyHeight - this.windowHeight;		// 获取可滚动的高度，防止因窗口大小变化导致页面滚动高度比例计算错误
	};

	LazyLoadingScroll.prototype.scrollData = function () {
		var nowScroll = this.$window.scrollTop();		// 获取当前滚动的位置
		this.scrollHeight = this.bodyHeight - this.windowHeight;		// 获取可滚动的高度，防止页面滚动高度比例计算错误
		if ((nowScroll > this.scrollHeight * this.scrollRate) && (nowScroll > this.oldScroll) && this.loadJudge && this.tabJudge) {		// 如果页面滚动距离超过设定比例，且之前的Ajax请求已经处理完成，则开始加载。	同时需要满足当前滚动位置大雨上一次滚动的位置，即页面为向下鼓动
			this.loadJudge = false;		// 变更判断是否加载中的变量为true，表示数据已经加载完成
			this.ajaxData();		// 通过ajax请求数据
		}
		this.oldScroll = nowScroll;		// 存储当前滚动的位置，以便下一次滚动时判断
	};

	LazyLoadingScroll.prototype.ajaxJudge = function(judge){		// 函数运行结果为将判断当前内容是否可以加载的变量，返回到ajax加载函数中，该函数在继承之后需要重写，变更返回值为定义的数组
		this.tabJudge = judge;
	};

	/*
	 * 10
	 * [ajaxPaging 使用Ajax获取后台数据实现懒加载效果]
	 * @param  {[对象]} getDataEle [传入的对象，其中定义需要传入数据的标签]
	 * @date 2016.05.24
	 * @auther Lee Chen
	 * demo 
		ajaxPaging({
			pagingBtn: $('.points-info ol'),		// 获取分页按钮的父级
			btnUrl: '../pagingnum.php',		// 定义获取分页页数的链接
			previousBtn: '<li class="previous"></li>',		// 定义上一页的标签
			nextBtn: '<li class="next"></li>',		// 定义下一页的标签
			numBtn: '<li></li>',		// 定义按钮的标签
			ellipsisBtn: '<li class="ellipsis"></li>',		// 定义显示省略号的标签1
			serialBtnNum: 5,		// 定义显示的数值按钮个数
			loadUrl: '../pagingdata.php?pageNum=',		// 定义获取展示数据的链接
			pagingEle: $('.points-info ul'),		// 获取填充展示数据的父级
			htmlFun: function (data) {		// 设置加载展示数据的结构
				return '<li class="clearfix">' + 
					'<span>' + data.time + '</span>' + 
					'<span>' + data.number + '</span>' + 
					'<span>' + data.name + '</span>' + 
					'<span>' + data.point + '</span>' + 
					'<span>' + data.status + '</span>' + 
					'<span>' + data.remark + '</span>' + 
				'</li>'
			},
			nowPageClass: 'selected',		// 定义选中标签的类名
			nowPageCSS: {		// 定义选中标签的CSS属性
				'color': '#fff'
			},
			ellipsisCSS: {		// 定义省略号标签的CSS属性
				'border': '1px solid transparent',
				'cursor': 'auto'
			},
			leftRightBtnCSS: {		// 定义向左向右标签的CSS属性
				'cursor': 'not-allowed'
			}
		});
	 */

	function ajaxPaging(pagingObj) {
		var maxPages = 0;		// 定义变量存储页面最大数量
		var nowPage = 0;		// 定义变量存储当前选中的页面索引值
		var nowPage = 0;		// 定义变量存储当前选中的页面索引值
		var scrollHeight = 0;		// 定义变量存储分页按钮点击时的滚动条高度
		var $window = $(window);		// 获取window

		$.ajax({
			type: 'get',
			dataType: 'json',
			url: pagingObj.btnUrl,		// 利用链接发送加载的编号
			cache: false,
			success: function (data) {
				maxPages = data;		// 将后台传入的数据页数存储
				if (maxPages > 0) {
					createBtnEle();		// 添加按钮标签的函数
					ajaxData();		// 从后台获取数据
					addSerial();		// 为按钮添加自定义属性，指定获取的数据页码
				} else {
					if (pagingObj.loadingHint.css('display') == 'block') {
						pagingObj.loadingHint.css({
							display: 'none'
						})
					}
				}
				setCss();		// 为按钮设置相应的CSS和类名
			}
		});

		if (pagingObj.jumpInput && pagingObj.jumpBtn) {
			var $jumpInput = $(pagingObj.jumpInput);
			var $jumpBtn = $(pagingObj.jumpBtn);
			var reg = /[.]+/;
			$jumpBtn.on('click', function () {
				var jumpNum = Number($jumpInput.val());		// 使用事件委托，获取当前点击的页码值
				
				if (isNumber(jumpNum) && jumpNum > 0 && jumpNum <= maxPages && (jumpNum - 1 != nowPage)) {		// 当页码值存在或者为0时运行
					if (jumpNum - Math.floor(jumpNum) > 0) {
						$jumpInput.val(Math.floor(jumpNum));
					} else {
						nowPage = jumpNum - 1;		// 保存点击的页码值，为加载的页面的页码值
						createBtnEle();		// 添加按钮标签的函数
						ajaxData();		// 从后台获取数据
						addSerial();		// 为按钮添加自定义属性，指定获取的数据页码
						setCss();		// 为按钮设置相应的CSS和类名
					}
				} else if (isNaN(jumpNum)) {
					$jumpInput.val(nowPage + 1);
				} else if (jumpNum <= 0) {
					$jumpInput.val(1);
				} else if (jumpNum > maxPages) {
					$jumpInput.val(maxPages);
				} else if (jumpNum - 1 == nowPage) {
					
				}
			})
		}

		function ajaxData() {
			scrollHeight = $window.scrollTop();		// 存储数据加载之前的滚动条高度
			$.ajax({
				type: 'get',
				dataType: 'json',
				url: pagingObj.loadUrl + nowPage,		// 利用链接发送加载的编号
				cache: false,
				success: function (data) {
					addhtml = '';		// 每次加载之前，清空已加载的数据
					if (pagingObj.loadingHint.css('display') == 'block') {
						pagingObj.loadingHint.css({
							display: 'none'
						})
					}
					if (maxPages > 0) {
						for (var i = 0; i < data.length; i++) {		// 使用for循环加载数据到
							addhtml += pagingObj.htmlFun(data[i]);
						}
						pagingObj.pagingEle.children().remove();		// 清空已经加载的数据
						pagingObj.pagingEle.append(addhtml);		// 将添加数据后的结构添加到页面中
						if (pagingObj.callback) {		// 如果有定义回调函数，则执行
							pagingObj.callback(pagingObj);
						}
						$jumpInput.val(nowPage + 1);
						$window.scrollTop(scrollHeight);		// 为页面指定滚动条高度为数据加载之前的高度
					}
				}
			});
		}

		function createBtnEle() {		// 添加按钮标签的函数
			pagingObj.pagingBtn.children().remove();		// 添加标签之前先将现有的标签都清除
			if (maxPages > pagingObj.serialBtnNum) {		// 如果最大页面数量大于显示的数字按钮数目时，页码按钮显示在最左边，添加如下标签
				if (nowPage < pagingObj.serialBtnNum - 1) {		// 当页码在0 ~ pagingObj.serialBtnNum - 1之间时
					pagingObj.pagingBtn.append(pagingObj.previousBtn);		// 添加向前按钮
					for (var i = 0; i < pagingObj.serialBtnNum; i++) {
						pagingObj.pagingBtn.append(pagingObj.numBtn);		// 使用for循环添加数字按钮
					}
					pagingObj.pagingBtn.append(pagingObj.ellipsisBtn);		// 添加省略号按钮
					pagingObj.pagingBtn.append(pagingObj.numBtn);		// 添加最后一页的按钮
					pagingObj.pagingBtn.append(pagingObj.nextBtn);		// 添加下一页按钮
				} else if (nowPage >= (pagingObj.serialBtnNum - 1) && (nowPage <= maxPages - pagingObj.serialBtnNum)) {		// 当页码不在最大和最小部分时，页码按钮显示在整排按钮的中央
					pagingObj.pagingBtn.append(pagingObj.previousBtn);		// 添加向前按钮
					pagingObj.pagingBtn.append(pagingObj.numBtn);		// 添加第一页的按钮
					pagingObj.pagingBtn.append(pagingObj.ellipsisBtn);		// 添加省略号按钮
					for (var i = 0; i < pagingObj.serialBtnNum; i++) {		// 使用for循环添加数字按钮
						pagingObj.pagingBtn.append(pagingObj.numBtn);
					}
					pagingObj.pagingBtn.append(pagingObj.ellipsisBtn);		// 添加省略号按钮
					pagingObj.pagingBtn.append(pagingObj.numBtn);		// 添加最后一页的按钮
					pagingObj.pagingBtn.append(pagingObj.nextBtn);		// 添加下一页按钮
				} else if (nowPage > maxPages - pagingObj.serialBtnNum) {		// 当页码处于最后几位时，页码按钮显示在最右边
					pagingObj.pagingBtn.append(pagingObj.previousBtn);		// 添加向前按钮
					pagingObj.pagingBtn.append(pagingObj.numBtn);		// 添加最后一页的按钮
					pagingObj.pagingBtn.append(pagingObj.ellipsisBtn);		// 添加省略号按钮
					for (var i = 0; i < pagingObj.serialBtnNum; i++) {		// 使用for循环添加数字按钮
						pagingObj.pagingBtn.append(pagingObj.numBtn);
					}
					pagingObj.pagingBtn.append(pagingObj.nextBtn);		// 添加下一页按钮
				}
			} else if (maxPages > 0 && maxPages <= pagingObj.serialBtnNum) {
				pagingObj.pagingBtn.append(pagingObj.previousBtn);		// 添加向前按钮
				for (var i = 0; i < maxPages; i++) {
					pagingObj.pagingBtn.append(pagingObj.numBtn);		// 使用for循环添加数字按钮
				}
				pagingObj.pagingBtn.append(pagingObj.nextBtn);		// 添加下一页按钮
			}
		}

		function addSerial() {		// 为按钮添加自定义属性，指定获取的数据页码
			var btnLen = pagingObj.pagingBtn.children().length;		// 获取按钮的数量
			nowPage = Number(nowPage);		// 获取当前按钮的索引值
			if (maxPages > pagingObj.serialBtnNum) {		// 如果最大页面数量大于显示的数字按钮数目时，页码按钮显示在最左边，添加如下标签
				if (nowPage < pagingObj.serialBtnNum - 1) {		// 当页码在0 ~ pagingObj.serialBtnNum - 1之间时
					for (var i = 1; i <= pagingObj.serialBtnNum; i++) {		// 使用for循环为按钮添加页码值
						pagingObj.pagingBtn.children().eq(i).attr({'page-num': i - 1});		// 为按钮添加自定义属性，存储获取数据的页码值
						pagingObj.pagingBtn.children().eq(i).html(i);		// 定义显示在按钮上的页码，该值为后台传输的页码加1
					}
					pagingObj.pagingBtn.children().eq(btnLen - 2).attr({'page-num': maxPages - 1});		// 为下一页按钮添加自定义属性，存储获取数据的页码值
					pagingObj.pagingBtn.children().eq(btnLen - 2).html(maxPages);		// 为下一页按钮添加显示在按钮上的页码，该值为后台传输的页码加1
				} else if (nowPage >= (pagingObj.serialBtnNum - 1) && (nowPage <= maxPages - pagingObj.serialBtnNum)) {		// 当页码不在最大和最小部分时，页码按钮显示在整排按钮的中央
					pagingObj.pagingBtn.children().eq(0).attr({'page-num': nowPage - 1});		// 为上一页按钮添加自定义属性，存储获取数据的页码值
					pagingObj.pagingBtn.children().eq(1).attr({'page-num': 0});		// 为第一页按钮添加自定义属性，存储获取数据的页码值
					for (var i = 3; i < 3 + pagingObj.serialBtnNum; i++) {		// 使用for循环添加数字按钮
						pagingObj.pagingBtn.children().eq(i).attr({'page-num': nowPage + i - pagingObj.serialBtnNum});		// 为按钮添加自定义属性，存储获取数据的页码值
						pagingObj.pagingBtn.children().eq(i).html(nowPage + i - pagingObj.serialBtnNum + 1);		// 定义显示在按钮上的页码，该值为后台传输的页码加1
					}
					pagingObj.pagingBtn.children().eq(btnLen - 2).attr({'page-num': maxPages - 1});		// 为最后一页按钮添加自定义属性，存储获取数据的页码值
					pagingObj.pagingBtn.children().eq(btnLen - 2).html(maxPages);		// 定义显示在按钮上的页码
					pagingObj.pagingBtn.children().eq(1).attr({'page-num': 0});		// 为第一页按钮添加自定义属性，存储获取数据的页码值
					pagingObj.pagingBtn.children().eq(1).html(1);		// 定义显示在按钮上的页码
				} else if (nowPage > maxPages - pagingObj.serialBtnNum) {		// 当页码处于最后几位时，页码按钮显示在最右边
					for (var i = btnLen - 1 - pagingObj.serialBtnNum; i < btnLen - 1; i++) {		// 使用for循环添加数字按钮的页码值
						pagingObj.pagingBtn.children().eq(i).attr({'page-num': maxPages + i - pagingObj.serialBtnNum - 3});		// 为按钮添加自定义属性，存储获取数据的页码值
						pagingObj.pagingBtn.children().eq(i).html(maxPages + i - pagingObj.serialBtnNum - 2);		// 定义显示在按钮上的页码，该值为后台传输的页码加1
					}
					pagingObj.pagingBtn.children().eq(1).attr({'page-num': 0});		// 为第一页按钮添加自定义属性，存储获取数据的页码值
					pagingObj.pagingBtn.children().eq(1).html(1);		// 定义显示在按钮上的页码
				}
				if (nowPage > 0) {		// 如果当前页码值大于0，则为上一页按钮添加页码值
					pagingObj.pagingBtn.children().eq(0).attr({'page-num': nowPage - 1});
				}
				if (nowPage < maxPages - 1) {		// 如果当前页码值小于最大值时，则为上一页按钮添加页码值
					pagingObj.pagingBtn.children().eq(btnLen - 1).attr({'page-num': nowPage + 1});
				}
			} else if (maxPages > 0 && maxPages <= pagingObj.serialBtnNum) {
				if (nowPage > 0) {		// 如果当前页码值大于0，则为上一页按钮添加页码值
					pagingObj.pagingBtn.children().eq(0).attr({'page-num': nowPage - 1});
				}
				for (var i = 1; i <= maxPages; i++) {		// 使用for循环为按钮添加页码值
					pagingObj.pagingBtn.children().eq(i).attr({'page-num': i - 1});		// 为按钮添加自定义属性，存储获取数据的页码值
					pagingObj.pagingBtn.children().eq(i).html(i);		// 定义显示在按钮上的页码，该值为后台传输的页码加1
				}
				if (nowPage < maxPages - 1) {		// 如果当前页码值小于最大值时，则为上一页按钮添加页码值
					pagingObj.pagingBtn.children().eq(btnLen - 1).attr({'page-num': nowPage + 1});
				}
			}
		}

		function setCss() {		// 为按钮设置相应的CSS和类名
			var $btn = pagingObj.pagingBtn.children();		// 获取分页按钮
			var btnLen = $btn.length;		// 获取按钮的数量
			var btnOuterWidth = $btn.outerWidth(true);		// 获取分页按钮的总宽度
			pagingObj.pagingBtn.width(btnOuterWidth * btnLen);		// 设定分页按钮父级宽度为按钮总宽度，用于父级的水平居中设置
			nowPage = Number(nowPage);		// 获取当前按钮的索引值
			if (maxPages > pagingObj.serialBtnNum) {		// 如果最大页面数量大于显示的数字按钮数目时，页码按钮显示在最左边，添加如下标签

				pagingObj.jumpBtnBox.css({
					display: 'block'
				})
				if (nowPage < pagingObj.serialBtnNum - 1) {		// 当页码在0 ~ pagingObj.serialBtnNum - 1之间时
					pagingObj.pagingBtn.children().eq(nowPage + 1).addClass(pagingObj.nowPageClass);		// 为当前页码的按钮添加类名
					pagingObj.pagingBtn.children().eq(nowPage + 1).css(pagingObj.nowPageCSS);		// 为当前页码的按钮添加CSS属性
					pagingObj.pagingBtn.children().eq(btnLen - 3).css(pagingObj.ellipsisCSS);		// 
					if (nowPage == 0) {		// 当显示按钮为第一个时，为上一页按钮添加CSS属性
						pagingObj.pagingBtn.children().eq(0).css(pagingObj.leftRightBtnCSS);
					}
				} else if (nowPage >= (pagingObj.serialBtnNum - 1) && (nowPage <= maxPages - pagingObj.serialBtnNum)) {		// 当页码不在最大和最小部分时，页码按钮显示在整排按钮的中央
					pagingObj.pagingBtn.children().eq(2 + Math.ceil(pagingObj.serialBtnNum / 2)).addClass(pagingObj.nowPageClass);		// 为当前页码的按钮添加类名
					pagingObj.pagingBtn.children().eq(2 + Math.ceil(pagingObj.serialBtnNum / 2)).css(pagingObj.nowPageCSS);		// 为当前页码的按钮添加CSS属性
					pagingObj.pagingBtn.children().eq(btnLen - 3).css(pagingObj.ellipsisCSS);		// 为省略号按钮添加CSS属性
					pagingObj.pagingBtn.children().eq(2).css(pagingObj.ellipsisCSS);		// 为省略号按钮添加CSS属性
				} else if (nowPage > maxPages - pagingObj.serialBtnNum) {		// 当页码处于最后几位时，页码按钮显示在最右边
					pagingObj.pagingBtn.children().eq(nowPage - maxPages - pagingObj.serialBtnNum + Math.ceil(pagingObj.serialBtnNum / 2) + 1).addClass(pagingObj.nowPageClass);		// 为当前页码的按钮添加类名
					pagingObj.pagingBtn.children().eq(nowPage - maxPages - pagingObj.serialBtnNum + Math.ceil(pagingObj.serialBtnNum / 2) + 1).css(pagingObj.nowPageCSS);		// 为当前页码的按钮添加CSS属性
					pagingObj.pagingBtn.children().eq(2).css(pagingObj.ellipsisCSS);		// 为省略号按钮添加CSS属性
					if (nowPage == maxPages - 1) {
						pagingObj.pagingBtn.children().eq(btnLen - 1).css(pagingObj.leftRightBtnCSS);		// 为下一页按钮添加CSS属性
					}
				}
				pagingObj.noDataHint.css({
					display: 'none'
				})
			} else if (maxPages > 0 && maxPages <= pagingObj.serialBtnNum) {
				pagingObj.jumpBtnBox.css({
					display: 'block'
				})
				pagingObj.pagingBtn.children().eq(nowPage + 1).addClass(pagingObj.nowPageClass);		// 为当前页码的按钮添加类名
				pagingObj.pagingBtn.children().eq(nowPage + 1).css(pagingObj.nowPageCSS);		// 为当前页码的按钮添加CSS属性
				if (nowPage == 0) {		// 当显示按钮为第一个时，为上一页按钮添加CSS属性
					pagingObj.pagingBtn.children().eq(0).css(pagingObj.leftRightBtnCSS);
				}
				if (nowPage == maxPages - 1) {
					pagingObj.pagingBtn.children().eq(btnLen - 1).css(pagingObj.leftRightBtnCSS);		// 为下一页按钮添加CSS属性
				}
				pagingObj.noDataHint.css({
					display: 'none'
				})
			} else if (maxPages == 0) {
				pagingObj.noDataHint.css({
					display: 'block'
				})
			}
		}

		pagingObj.pagingBtn.on('click', function (e) {
			var clickNum = Number($(e.target).attr('page-num'));		// 使用事件委托，获取当前点击的页码值
			if (clickNum || clickNum == 0) {		// 当页码值存在或者为0时运行
				if (clickNum != nowPage) {		// 如果页码值和当前显示的页码值不相同则跳转页面
					nowPage = clickNum;		// 保存点击的页码值，为加载的页面的页码值
					createBtnEle();		// 添加按钮标签的函数
					ajaxData();		// 从后台获取数据
					addSerial();		// 为按钮添加自定义属性，指定获取的数据页码
					setCss();		// 为按钮设置相应的CSS和类名
				}
			}
		})
	}

	/*
	 * 11
	 * [timeBetweenHourAjax 从后台获取当前服务器的小时数，判断是否在某个范围内]
	 * @param  {[数字]} timeStart [开始的小时数]
	 * @param  {[数字]} timeEnd [结束的小时数]
	 * @param  {[字符串]} loadUrl [获取数据的链接]
	 * @param  {[函数]} callback [回调函数]
	 * @date 2016.05.28
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	timeBetweenHourAjax(8, 17, '../loaddata.php', callback)
	 */

	function timeBetweenHourAjax(timeStart, timeEnd, loadUrl, callback) {
		var timeJudge;
		$.ajax({
			'type': 'post',
			'dataType': 'json',
			'url': loadUrl,
			'success': function (data) {
				var nowDate = new Date();		// 通过后台获取当前时间
				var nowHour = nowDate.getHours();
				if (nowHour >= timeStart && nowHour < timeEnd) {
					timeJudge = true;
				} else {
					timeJudge = false;
				}
				if (callback) {
					callback(timeJudge);
				}
			}
		})
	}

	/*
	 * 13
	 * [preLoadPic 实现图片预加载，提供进度条计算，以及加载完成后回调]
	 * @param  {[对象]} obj [定义传参数据]
	 * @date 2016.08.04
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	preLoadPic({
			files : [],		// 加载的图片存储在数组中
			progress : function(precent, currentImg) {		// 每加载完成一张图片回调
				具体代码
			},
			complete : function() {		// 加载完成后回调
				具体代码
			}
	 	})
	 */
	function preLoadPic(obj) {
		return new filePreLoad(obj);
	}
	function filePreLoad(obj) {
		this.files = obj.files;
		this.progress = obj.progress;
		this.complete = obj.complete;
		// 当前加载数量为0
		this.current = 0;
		// 容器设置
		this.box = document.createElement('div');
		this.box.style.cssText = 'overflow:hidden; position: absolute; left: -9999px; top: 0; width: 1px; height: 1px;';
		document.body.appendChild(this.box);
		this.getFiles();
	}

	// 获取每一个图片
	filePreLoad.prototype.getFiles = function() {
		var fileArr = [];
		for (var i = 0; i < this.files.length; i++) {
			fileArr[i] = this.files[i];
			this.loadImg(fileArr[i], i);
		};
	}

	// 加载图像
	filePreLoad.prototype.loadImg = function(file, index) {
		var _this = this;
		var newImg = new Image();

		newImg.onload = function(){
			newImg.onload = null;
			_this.loadFtn(newImg, index);
		}

		newImg.src = file;
	}

	// 执行相关回调
	filePreLoad.prototype.loadFtn = function(currentImg, index) {
		this.current++;
		this.box.appendChild(currentImg);
		if (this.progress) {
			var precentage = parseInt(this.current / this.files.length * 100);
			this.progress(precentage, currentImg, index);
		};
		if (this.current == this.files.length) {
			if (this.complete) {
				this.complete();
			};
		};
	}


	/*
	 * 14
	 * [ls 使用本地存储，判断存储的数据类型，若是数组，则可指定长度，数据存储在最后一个，且会清除最早的数据，若数据为对象或字符串，则直接替换。若最后存储的数据为空，则返回false。不传入data参数时，则直接返回lsName对应的值，为空则返回false]
	 * @param  {[字符串]} lsName [定义本地存储的名字]
	 * @param  {[字符串]} type [定义本地存储的数据类型]
	 * @param  {[除了布尔值和undefined、null]} data [存入本地存储数组的数据]
	 * @param  {[数字]} len [定义本地存储的数组长度]
	 * @date 2016.08.04
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	ls('payData', {
			"result": true,
			"info": {
				"order_id": 1151,
				"payondersn": "IB2016080911390377809",
				"money": "1168.20",
				"ondersn": [
					"IB2016080911390377809"
				],
				"pay_id": 9,
				"pay_name": "支付宝"
			},
			"msg_info": "下单成功"
		})
	 */
	function ls(lsName, type, data, len) {
		if (window.localStorage) {
			var ls = window.localStorage;		// 创建本地存储对象
			if (data) {
				if (type == 'a' || type == 'array') {
					var lsArr = [];
					ls.getItem(lsName) == '' ? ls.setItem(lsName, '{}') : '';
					var lsRawData = JSON.parse(ls.getItem(lsName));
					if (lsRawData) {		// 判断本地存储是否原有数据
						if ($.isArray(lsRawData)) {
							lsArr = JSON.parse(ls.getItem(lsName));		// 读取本地存储的值并存入变量lsArr中
						} else {
							ls.setItem(lsName, JSON.stringify(lsArr));
						}
					} else {
						ls.setItem(lsName, JSON.stringify(lsArr));		// 将空数据存入本地存储
					}
					if (len) {
						if (lsArr.length < len) {		// 数组未达到最大长度，则添加数据
							lsArr.push(data);
						} else {		// 数组达到最大长度，则删除第一个值，data添加进数组
							lsArr.shift();
							lsArr.push(data);
						}
					} else {		// 若未设定数组最大长度，则不断添加数据
						lsArr.push(data);
					}
					ls.setItem(lsName, JSON.stringify(lsArr));		// 将数据存入本地存储
				} else if (type == 'o' || type == 'object' || type == 'f' || type == 'function' || $.isPlainObject(data) || $.isArray(data) || $.isFunction(data)) {		// 创建不同类型的变量
					ls.setItem(lsName, JSON.stringify(data));
				} else if (type == 's' || type == 'string' || type == 'n' || type == 'number' || typeof data == 'string' || typeof data == 'number') {
					ls.setItem(lsName, data);
				}
				return showData();
			} else {
				return showData();
			}
		} else {
			// alert('不支持本地存储');
			hint.show('您的浏览器不支持本地存储，请重新打开浏览器或更换浏览器');
		}

		function showData() {
			var lsData = ls.getItem(lsName);

			if (type == 'a' || type == 'o' || type == 'f' || type == 'array' || type == 'object' || type == 'function' || $.isPlainObject(data) || $.isArray(data) || $.isFunction(data)) {
				if ((lsData == '') || (lsData == undefined)) {
					if (type == 'o') {
						lsData = '{}';
					} else if (type == 'a') {
						lsData = '[]';
					}
				}
				return lsData = JSON.parse(lsData);
			} else if (type == 's' || type == 'string') {
				return lsData;
			} else if (type == 'n' || type == 'number') {
				return Number(lsData);
			}
		}
	}

	/*
	 * 15
	 * [lsDel 删除本地存储中对应的值，可选仅清空数据]
	 * @param  {[字符串]} lsName [定义本地存储的名字]
	 * @param  {[字符串、数字]} data [存入本地存储数组的数据]
	 * @param  {[数字]} len [定义本地存储的数组长度]
	 * @date 2016.08.04
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	core.lsDel(['username', 'username', 'username'], 'remove')
	 */
	function lsDel(lsName, type) {
		if (window.localStorage) {
			var ls = window.localStorage;		// 创建本地存储对象
			if (type == 'remove' || type == undefined) {		// 移除整个对应本地存储的值
				if ($.isArray(lsName)) {
					for (var i = 0; i < lsName.length; i++) {
						ls.removeItem(lsName[i]);
					}
				} else {
					ls.removeItem(lsName);
				}
			} else if (type == 'delete') {
				if ($.isArray(lsName)) {
					for (var i = 0; i < lsName.length; i++) {
						ls.setItem(lsName[i], '');
					}
				} else {
					ls.setItem(lsName, '');		// 清空本地存储中的数据
				}
			}
		} else {
			// alert('不支持本地存储');
			hint.show('数据获取失败，请重新打开网页');
		}
	}

	/*
	 * 16
	 * [include 使用get方式引入公共结构]
	 * @param  {[字符串]} lsName [定义本地存储的名字]
	 * @param  {[字符串、数字]} data [存入本地存储数组的数据]
	 * @param  {[数字]} len [定义本地存储的数组长度]
	 * @date 2016.08.04
	 * @auther Lee Chen
	 * @HTML
		
	 * demo 
	 	lsDel('username', 'remove')
	 */
	function include(obj) {
		if (obj.loading) {
			obj.loading.css({
				display: 'block'
			})
		}
		if (obj.ele.length > 0) {
			$.get(obj.url, function (data) {
				if (obj.cut) {
					data = getHtml(data, obj.cut, obj.inside);
				}
				if (obj.before) {
					obj.before(obj.ele, data);
				}
				if (obj.type == 'before') {
					obj.ele.before(data);
				} else if (obj.type == 'after') {
					obj.ele.after(data);
				} else {
					obj.ele.append(data);
				}
				if (obj.after) {
					obj.after(obj.ele, data);
				}
				if (obj.loading) {
					obj.loading.css(dn)
				}
				if (obj.callback) {
					obj.callback(data);
				}
			}, 'html');
		}
	}

	/************************** Math部分 **************************/
		/*
	 * 1
	 * [decimalRound 将小数按照所指定的位数四舍五入]
	 * @param  {[数字、数字字符串]} num [需要进行四舍五入的小数]
	 * @param  {[数字、数字字符串]} digits   [四舍五入的位数]
	 * @date 2016.02.13
	 * @auther Lee Chen
	 * demo decimalRound("0.555","2");
	 */
	function decimalRound(num, digits) {
		if (digits >= 0) {
			return ((Math.round(Number(num) * Math.pow(10, digits))) / Math.pow(10, digits));		// 	Math.pow()方法输出10的digits次方，使用Math.round()方法进行四舍五入到整数，之后再除以Math.pow(10, digits)恢复到原小数位
		} else {
			return "请输入正整数";
		}
	}

	/*
	 * 2
	 * [changePercentage 将数字转换为百分比，可设定保留的小数位数]
	 * @param  {[数字、数字字符串]} num [需要进行转换的数字]
	 * @param  {[数字、数字字符串]} digits   [四舍五入的位数]
	 * @date 2016.02.13
	 * @auther Lee Chen
	 * demo changePercentage(0.4, 0);		// 输出40%
	 */
	function changePercentage(num, digits) {
		return decimalRound(num * 100, digits) + '%'		// 将数值四舍五入之后，添加百分号返回
	}

	/*
	 * 3
	 * [bubbleSortSmall 由小到大的冒泡排序，支持根据第一个数组的排序同时排列第二个数组]
	 * @param  {[数组]} array [需要进行排序的数组]
	 * @date 2016.02.21
	 * @auther Lee Chen
	 * demo bubbleSortSmall([3, 5, 6, 2, 89, 1, 0, 34]);
	 */
	function bubbleSortSmall(array, dataArr) {
		for (var i = 0; i < array.length; i++) {		// 每次循环都判断是否有满足对比条件的值，若有则将其调换到相应位置
			for (var j = 0; j < array.length - i; j++) {		// 每遍历一次数组，实现两两调换，将最早遇到的满足对比条件的值，进行调换到相应位置
				if (array[j] > array[j + 1]) {		// 若当前值大于下一位的值，则两个值调换位置
					var tmp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = tmp;
					if (dataArr) {
						var data = dataArr[j];
						dataArr[j] = dataArr[j + 1];
						dataArr[j + 1] = data;
					}
				}
			}
		}
		return [array, dataArr];
	}

	/*
	 * 4
	 * [bubbleSortBig 由大到小的冒泡排序，支持根据第一个数组的排序同时排列第二个数组]
	 * @param  {[数组]} array [需要进行排序的数组]
	 * @date 2016.02.21
	 * @auther Lee Chen
	 * demo bubbleSortBig([3, 5, 6, 2, 89, 1, 0, 34]);
	 */
	function bubbleSortBig(array, dataArr) {
		for (var i = 0; i < array.length; i++) {		// 每次循环都判断是否有满足对比条件的值，若有则将其调换到相应位置
			for (var j = 0; j < array.length - i; j++) {		// 每遍历一次数组，实现两两调换，将最早遇到的满足对比条件的值，进行调换到相应位置
				if (array[j] < array[j + 1]) {		// 若当前值小于下一位的值，则两个值调换位置
					var tmp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = tmp;
					if (dataArr) {
						var data = array[j];
						dataArr[j] = dataArr[j + 1];
						dataArr[j + 1] = data;
					}
				}
			}
		}
		return [array, dataArr];
	}

	/*
	 * 5
	 * [isNumber 使用isNaN方法判断传入参数是否为数字]
	 * @param  {[任何类型]} num [判断是否为数字的参数]
	 * @date 2016.05.26
	 * @auther Lee Chen
	 * demo isNumber(5);
	 */
	function isNumber(num) {
		if (isNaN(num)) {		// 使用isNaN函数检验num是否为非数值，若是则isNaN函数结果为true，则返回false
			return false;
		} else {
			return true;
		}
	}

	/*
	 * 6
	 * [hideCenterPhoneNum 使用正则隐藏中间4位的手机号]
	 * @param  {[jQuery获取的标签]} hideEle [将该标签的数据获取，并填充到该标签中]
	 * @date 2016.05.27
	 * @auther Lee Chen
	 * demo hideCenterPhoneNum($('span'), 15880200025);
	 */
	function hideCenterPhoneNum(phoneNum, hideEle) {
		var reg = /^(.)(.)(.).{4}(.)(.)(.)(.)$/g;		// 正则查找前3位和后4位，中间4位忽略，则前3位的编号是$0、$1、$2，后4位编号为$4、$5、$6、$7
		var regstr = phoneNum.toString().replace(reg, "$1$2$3****$4$5$6$7");		// 将前3位和后4位的值去除，中间4位使用*号替代
		hideEle && hideEle.html(regstr);		// 将转换的值填入相应标签
		return regstr;
	}

	/*
	 * 7
	 * [hideCenterStr 将字符串的中间字符替代为*号，仅显示头尾两个字符]
	 * @param  {[字符串或数字]} str [需要隐藏的字符串]
	 * @date 2016.06.12
	 * @auther Lee Chen
	 * demo hideCenterStr('中文可以吗');		// 输出 中***吗
	 * demo hideCenterStr('stringloading')		// 输出 s***********g
	 */
	function hideCenterStr(str) {
		var reg = /^(.).+(.)$/gi;		// 正则第一位和最后一位分别对应$1、$2
		var replaceStr = '';

		for (var i = 0; i < str.length - 2; i++) {		// 使用for循环存储需要隐藏相应位数的*号
			replaceStr += '*';
		}

		var regStr = str.replace(reg, '$1' + replaceStr + '$2');		// 将前3位和后4位的值去除，中间4位使用*号替代
		return regStr;
	}

	/*
	 * 8
	 * [setLevelRange 根据分数在某个范围内，计算相应的等级]
	 * @param  {[字符串]} levelName [需要显示的登记名称]
	 * @param  {[数字]} levelNum [用于计算等级的数据]
	 * @param  {[数字]} everyLevelDif [每个等级之间的差值]
	 * @param  {[数字]} levelStart [开始计算等级的数值]
	 * @param  {[数字]} levelEnd [最后一个等级的级别]
	 * @date 2016.05.30
	 * @auther Lee Chen
	 * demo setLevelRange('VIP', 0.33, 0.05, 0.05, 16);		// 输出VIP5
	 * demo setLevelRange('VIP', 0.88, 0.05, 0.05, 16);		// 输出VIP15
	 */
	function setLevelRange(levelName, levelNum, everyLevelDif, levelStart, levelEnd) {
		var levelNameArr = [];		// 用于存储等级名称的数组
		var levelArr = [];		// 用于存储判断等级标准的数组
		for (var i = 0; i < levelEnd; i++) {
			levelNameArr[i] = levelName + i;		// 存储等级名称到数组
			levelArr[i] = decimalRound(levelStart + i * everyLevelDif, 2);		// 存储等级判断值到数组
			if (levelArr[i] > levelNum) {		// 当前值小于当前等级级的值时
				return levelNameArr[i - 1];		// 返回等级名称为上一级的名称
			}
			if (levelArr[i] == levelNum) {		// 当前值等于当前等级值时，
				return levelNameArr[i];		// 返回等级名称为当前等级名称
			}
			if (levelNum >= levelArr[levelEnd - 1]) {		// 当前值大于最大等级值时
				return levelNameArr[levelEnd - 1];		// 返回最大等级名称
			}
		}
	}

	/*
	 * 9
	 * [setLevelConstant 根据分数为某个精确值，计算相应的等级]
	 * @param  {[字符串]} levelName [需要显示的登记名称]
	 * @param  {[数字]} levelNum [用于计算等级的数据]
	 * @param  {[数字]} everyLevelDif [每个等级之间的差值]
	 * @param  {[数字]} levelStart [开始计算等级的数值]
	 * @param  {[数字]} levelEnd [最后一个等级的级别]
	 * @date 2016.05.30
	 * @auther Lee Chen
	 * demo setLevelConstant('VIP', data.level_percentage, 0.05, 0.05, 16));		// 输出VIP7
	 */
	function setLevelConstant(levelName, levelNum, everyLevelDif, levelStart, levelEnd) {
		var levelNameArr = [];		// 用于存储等级名称的数组
		var levelArr = [];		// 用于存储判断等级标准的数组
		for (var i = 0; i < levelEnd; i++) {
			levelNameArr[i] = levelName + i;		// 存储等级名称到数组
			levelArr[i] = decimalRound(levelStart + i * everyLevelDif, 2);		// 存储等级判断值到数组
			if (levelArr[i] == levelNum) {		// 当前值等于当前等级值时，
				return levelNameArr[i];		// 返回等级名称为当前等级名称
			}
		}
	}

	/*
	 * 10
	 * [showDifDecimal 若传入的值为0，则显示0.00；若传入的值为0-1之间，则精确到digits0to1位小数；若传入的值≥1，则显示digitsMore1位小数，返回值类型为string，因数字类型会自动省略最后的0]
	 * @param  {[字符串]} num [判断小数位数是否足够的数值]
	 * @param  {[数字]} digits0to1 [传入的值为0-1之间，则精确到digits0to1位小数]
	 * @param  {[数字]} digitsMore1 [传入的值≥1，则显示digitsMore1位小数]
	 * @date 2016.05.30
	 * @auther Lee Chen
	 * demo showDifDecimal(0.12, 4, 2);
	 */
	function showDifDecimal(num, digits0to1, digitsMore1) {
		var absNum = Math.abs(num)
		if (absNum == 0) {		// 当num等于0时
			return '0.00';
		} else if (absNum > 0 && absNum < 1) {		// 当num处于0~1之间时
			num = decimalRound(num, digits0to1).toString();
			
			addZero(digits0to1);

			return num;
		} else if (absNum >= 1) {		// 当num大于等于1时
			num = decimalRound(num, digitsMore1).toString();
			addZero(digitsMore1);

			return num;
		}
		
		function addZero(digits) {
			var numSpl = num.split('.');		// 存储拆分的字符串

			if (numSpl[1]) {		// 依据.拆分字符串为一个数组，[0]为整数值，[1]为小数值，如果小数值存在，则执行

				var strTemp = '';		// 定义一个空字符串，用于存储当位数不足时，需要添加的0
				
				if (numSpl[1].length < digits) {		// 如果小数位数小于应显示的位数
					for (var i = 0; i < digits - numSpl[1].length; i++) {		// 使用for循环添加缺少的位数
						strTemp += '0';		// 添加缺少的位数为0
					}
				}

				num = num + strTemp;		// 利用字符串拼接，将不足位数补齐到原始值中
			} else {
				if (digits) {
					var strTemp = '.';		// 定义一个.字符串，用于存储当位数不足时，需要添加的0
					for (var i = 0; i < digits; i++) {		// 使用for循环添加缺少的位数
						strTemp += '0';		// 添加缺少的位数为0
					}

					num = num + strTemp;		// 利用字符串拼接，将不足位数补齐到原始值中
				} else {
					num = Number(num);
				}
			}
		}
	}

	/*
	 * 11
	 * [timeBetweenHour 判断时间是否在某个小时的范围内，是则返回true，否则返回false]
	 * @param  {[字符串]} hourStart [传入的开始时间]
	 * @param  {[数字]} hourEnd [传入的结束时间]
	 * @param  {[数字]} nowHour [需要判断的时间]
	 * @date 2016.05.31
	 * @auther Lee Chen
	 * demo timeBetweenHour(8, 17, 15));		// 输出true
	 */

	function timeBetweenHour(hourStart, hourEnd, nowHour) {
		if (nowHour >= hourStart && nowHour < hourEnd) {		// 当nowHour处于hourStart和hourEnd之间时，返回true
			return true;
		} else {
			return false;
		}
	}

	/*
	 * 12
	 * [findProp 根据传入的prop参数，查找obj对象中对应prop属性的值，并将其返回]
	 * @param  {[字符串]} prop [一个属性的选择器，根据此选择器查找到对象中的对应属性]
	 * @param  {[对象]} obj [需要查找相应属性的对象]
	 * @date 2016.07.11
	 * @auther Lee Chen
	 * demo findProp('loves.loves_list', data);		// 返回需要查找的属性值
	 */

	function findProp(prop, obj, obj2) {
		var strArr = prop.split('.');
		var judgeObj = {};
		for (var i = 0; i < strArr.length; i++) {
			judgeObj[strArr[i]] = false;
			// for (var j in obj) {
			// 	if (j == strArr[i]) {
			// 		obj = obj[j];
			// 		judgeObj[j] = true;
			// 	}
			// }
			if (obj[strArr[i]]) {
				obj = obj[strArr[i]];
				judgeObj[strArr[i]] = true;
			}
			if (obj2) {
				if (obj2[strArr[i]]) {
					obj2 = obj2[strArr[i]];
					judgeObj[strArr[i]] = true;
				}
			}
		}
		if (judgeObj[strArr[strArr.length - 1]]) {
			if (obj2) {
				return [obj, obj2];
			} else {
				return obj;
			}
		} else {
			console.log('未查找到属性选择器' + prop + '所指向的属性');
		}
	}

	/*
	 * 13
	 * [isIntDecimal 7.22判断传入的值是否为数字，包括整数和小数，9.7加入可判断小数位数的功能]
	 * @param  {[任何类型]} num [判断是否为数字的参数]
	 * @date 2016.09.07
	 * @auther Lee Chen
	 * demo isIntDecimal(5);
	 */
	function isIntDecimal(num, digits) {
		num = num.toString();
		if (num.match(zeroReg) || num.match(intReg) || num.match(decimalReg0to1) || num.match(decimalReg1p) || num.match(negInt) || num.match(negDemical)) {		// 使用isNaN函数检验num是否为非数值，若是则isNaN函数结果为true，则返回false
			if (digits) {
				var tmp = Number(num);
				if (tmp - Math.floor(tmp)) {
					if (num.match('[.][0-9]{0,' + digits + '}$')) {
						return true;
					} else {
						return false;
					}
				} else {
					return true;
				}
			} else {
				return true;
			}
		} else {
			return false;
		}
	}

	/*
	 * 14
	 * [getUrlData 正则获取当前页面url中str属性所对应的参数值]
	 * @param  {[字符串]} str [判断是否为数字的参数]
	 * @date 2016.07.23
	 * @auther Lee Chen
	 * demo getUrlData('cat_id');
	 */
	function getUrlData(data, str) {
		var reg = '';
		if (typeof data == 'string') {
			reg = '(^|[&?])' + data + '=([^&]*)(&|$)';
			var result = str ? str.match(reg) : window.location.href.match(reg);

			if (result) {
				return preventSpecial(result[2]);
			} else {
				return false;
			}
		} else if ($.isArray(data)) {
			var resultArr = [];
			var result = '';

			for (var i = 0; i < data.length; i++) {
				reg = '(^|[&?])' + data[i] + '=([^&]*)(&|$)';

				result = window.location.href.match(reg)
				if (result) {
					resultArr[i] = preventSpecial(result[2]);
				} else {
					resultArr[i] = false;
				}
			}

			return resultArr;
		} else if (typeof data == 'object') {
			var resultObj = {};
			var result = '';

			for (var i in data) {
				reg = '(^|[&?])' + data[i] + '=([^&]*)(&|$)';

				result = window.location.href.match(reg);
				if (result) {
					resultObj[i] = preventSpecial(result[2]);
				} else {
					resultObj[i] = undefined;
				}
			}

			return resultObj;
		}

		function preventSpecial(str) {
			if (str.match(/(.*)#/)) {
				return str.match(/(.*)#/)[1];
			} else {
				return str;
			}
		}
	}

	/*
	 * 15
	 * [getHtml 正则某个标签及其中所有内容]
	 * @param  {[字符串]} data [含有标签信息的字符串]
	 * @param  {[字符串]} str [需要获取数据的标签名]
	 * @date 2016.07.23
	 * @auther Lee Chen
	 * demo getHtml(data, 'p');
	 */
	function getHtml(data, str, inside) {
		var reg = '<' + str + '>(.*)</' + str + '>';		// 通过正则表达式匹配相应标签中的数据
		data = data.replace(/[\r\n]/g,'');		// 匹配之前先取出数据中的回车键，防止匹配错误

		if (inside) {
			return data.match(reg)[1];		// 将匹配结果返回，匹配结果不包含正则匹配的标签
		} else {
			return data.match(reg)[0];		// 将匹配结果返回，匹配结果包含正则匹配的标签
		}
	}

	/*
	 * 16
	 * [isArray 判断是否为数组]
	 * @param  {[数组]} arr [传入的参数，判断该参数是否为数组]
	 * @date 2016.07.27
	 * @auther Lee Chen
	 * demo isArray([1,2,3,1]);
	 */
	function isArr(arr){
		if (typeof Array.isArray == "function") {
			return Array.isArray(arr); 
		}else{
			return Object.prototype.toString.call(arr) == "[object Array]"; 
		}
	}

	/*
	 * 17
	 * [findAttr 在传入元素中查找含有某个属性值的元素，并将元素返回]
	 * @param  {[对象]} ele [jQuery获取的对象]
	 * @param  {[字符串]} attr [需要查找的属性名]
	 * @param  {[字符串]} data [需要查找的属性值]
	 * @date 2016.08.25
	 * @auther Lee Chen
	 * demo findAttr($goodsCon.eq(i).find('dl'), 'goodsId', $show.parents('dl').attr('goodsId'));
	 */
	function findAttr(ele, attr, data){
		var eleArr = [];
		for (var i = 0; i < ele.length; i++) {
			if (ele.eq(i).attr(attr) == data) {
				eleArr.push(ele.eq(i));
			}
		}
		if (eleArr.length > 0) {
			return eleArr;
		}
	}

	/*
	 * 18
	 * [isjQuery 判断对象是否为jQuery或Zepto对象]
	 * @param  {[对象]} object [jQuery或Zepto获取的对象]
	 * @date 2016.08.31
	 * @auther Lee Chen
	 * demo isjQuery($goodsCon);
	 */
	function isjQuery(object) {
		if (window.jQuery) {
			if (object instanceof jQuery) {
				return true;
			}
		}
		if (window.Zepto) {
			if ($.isArray(object) && object.selector && (typeof object.length == 'number')) {
				return true;
			}
		}
	}

	/*
	 * 19
	 * [arrJudge 判断一个数组中是否所有布尔值都为true]
	 * @param  {[对象]} object [jQuery或Zepto获取的对象]
	 * @date 2016.09.1
	 * @auther Lee Chen
	 * demo arrJudge(arr);
	 */
	function arrJudge(arr) {
		var sum = 0;
		var len = arr.length;

		for (var i = 0; i < arr.length; i++) {
			if (arr[i] == true) {
				sum++;
			}
		}

		if (sum == len) {
			return true;
		} else {
			return false;
		}
	}

	/*
	 * 20
	 * [phoneJudge 判断输入值是否是1开头的11位手机号]
	 * @param  {[字符串]} str [判断是否为字符串的手机号]
	 * @param  {[布尔值]} fixedLine [判断是否为固定电话，即至少7位数字的布尔值]
	 * @date 2016.09.01
	 * @auther Lee Chen
	 * demo phoneJudge('18559231815');
	 */
	function phoneJudge(str, fixedLine) {
		str = str.toString();
		if (str.match(phoneReg) && !fixedLine) {
			return true;
		} else if (str.match(/\d{7}/) && fixedLine) {
			return true;
		} else {
			return false;
		}
	}

	/*
	 * 21
	 * [emptyJudge 判断值是否为空，为空则返回false]
	 * @param  {[字符串]} str [判断是否为空]
	 * @date 2016.09.13
	 * @auther Lee Chen
	 * demo emptyJudge('18559231815');
	 */
	function emptyJudge(str) {
		if (str) {
			return true;
		} else {
			return false;
		}
	}

	/*
	 * 22
	 * [eleType 判断传入值类型为string，则通过该选择器获取标签并返回；类型为jQuery或Zepto对象，则返回其本身；类型为函数，可选返回用函数获取的标签，或返回函数本身]
	 * @param  {[字符串]} ele [传入判断的值]
	 * @param  {[布尔值]} judge [布尔值为true时，判断为直接返回函数本身，为其他值时，判断为运行函数之后，返回返回值，该参数将被传入ele函数运行]
	 * @date 2016.09.13
	 * @auther Lee Chen
	 * demo eleType('#userId');
	 */
	function eleType(ele, judge) {
		if (typeof ele == 'string') {
			return $(ele);
		} else if (isjQuery(ele)) {
			return ele;
		} else if (typeof ele == 'function') {
			if (judge == true) {
				return ele;
			} else {
				return ele(judge);
			}
		}
	}

	/*
	 * 23
	 * [phpDate 根据后台php传入的毫秒数，转换为js可用的date对象，并返回年、月、日、周几、小时、分钟、秒]
	 * @param  {[字符串]} time [传入判断的值]
	 * @date 2016.09.20
	 * @auther Lee Chen
	 * demo phpDate(time);
	 */
	function phpDate(time) {
		if (time != '0' || !time) {
			time = Number(time + '000');
			var date = new Date(time);
			return {
				year: date.getFullYear(),		// 从 Date 对象以四位数字返回年份。
				mon: doubleDigit(date.getMonth()) + 1,		// 从 Date 对象返回月份 (0 ~ 11)。
				day: doubleDigit(date.getDate()),		// 从 Date 对象返回一个月中的某一天 (1 ~ 31)。
				weekDay: doubleDigit(date.getDay()) + 1,		// 从 Date 对象返回一周中的某一天 (0 ~ 6)。
				hour: doubleDigit(date.getHours()),		// 返回 Date 对象的小时 (0 ~ 23)。
				min: doubleDigit(date.getMinutes()),		// 返回 Date 对象的分钟 (0 ~ 59)。
				sec: doubleDigit(date.getSeconds()),		// 返回 Date 对象的秒数 (0 ~ 59)。
				ymd: date.getFullYear() + '.' + doubleDigit(date.getMonth() + 1) + '.' + doubleDigit(date.getDate()),
				hms: doubleDigit(date.getHours()) + ':' + doubleDigit(date.getMinutes()) + ':' + doubleDigit(date.getSeconds()),
				hm: doubleDigit(date.getHours()) + ':' + doubleDigit(date.getMinutes()),
				ms: doubleDigit(date.getMinutes()) + ':' + doubleDigit(date.getSeconds())
			};
		} else {
			return {
				year: '',
				mon: '',
				day: '',
				weekDay: '',
				hour: '',
				min: '',
				sec: '',
				ymd: '',
				hms: '',
				hm: '',
				ms: ''
			};
		}
	}

	/*
	 * 24
	 * [doubleDigit 若传入数值为1位数，即小于10，则转换为两位数如01]
	 * @param  {[字符串]} num [传入判断的值]
	 * @date 2016.09.20
	 * @auther Lee Chen
	 * demo doubleDigit(1);
	 */
	function doubleDigit(num) {
		num = Number(num);

		if (num < 10) {
			return '0' + num;
		} else {
			return num
		}
	}

	/*
	 * 25
	 * [href 根据传入的链接进行跳转]
	 * @param  {[字符串]} num [传入判断的值]
	 * @date 2016.09.20
	 * @auther Lee Chen
	 * demo href('../index.html');
	 */
	function href(href) {
		window.location.href = href;
	}

	/*
	 * 26
	 * [splitTimeStr 将传入的10:10的时间格式转换为[10, 10]的数组格式输出，其中的值为数字]
	 * @param  {[字符串]} str [传入的时间值]
	 * @date 2016.09.23
	 * @auther Lee Chen
	 * demo splitTimeStr('10:30');
	 */
	function splitTimeStr(str) {
		var arr = str.toString().split(':');

		return [Number(arr[0]), Number(arr[1])];
	}

	/*
	 * 27
	 * [subString 将传入的字符串按照index截取]
	 * @param  {[字符串]} str [传入的时间值]
	 * @param  {[字符串]} str [传入的时间值]
	 * @param  {[字符串]} str [传入的时间值]
	 * @date 2016.09.24
	 * @auther Lee Chen
	 * demo subString('10:30');
	 */
	function subString(str, end, start) {
		str = str.toString();
		start = start || 0;
		if (typeof end == 'undefined') {
			end = str.length - 1;
		} else if (end == 0) {
			end = str.length;
		} else if (end < 0) {
			end = str.length + end;
		}
		return str.substring(start, end);
	}

	/*
	 * 28
	 * [hintHref 显示提示语之后间隔一定时间跳转页面]
	 * @param  {[字符串]} show [提示语]
	 * @param  {[字符串]} href [跳转的链接]
	 * @param  {[数字]} time [跳转的间隔时间]
	 * @date 2016.09.27
	 * @auther Lee Chen
	 * demo core.hintHref('您未登陆，请先登陆', '../login/merchant_login.html');
	 */
	function hintHref(show, href, time) {
		time = time || 2000;
		// show && hint.show(show);
		show && layerHint(show);
		setTimeout(function () {
			core.href(href);
		}, time);
	}

	/*
	 * 29
	 * [hintBack 显示提示语之后间隔一定时间返回上一页]
	 * @param  {[字符串]} show [提示语]
	 * @param  {[字符串]} href [跳转的链接]
	 * @param  {[数字]} time [跳转的间隔时间]
	 * @date 2016.09.30
	 * @auther Lee Chen
	 * demo subString('10:30');
	 */
	function hintBack(show, time, callback, num) {
		// show && hint.show(show);
		show && layerHint(show);
		setTimeout(function () {
			callback && callback();
			back(num);
		}, (time || 2000));
	}

	/*
	 * 30
	 * [back 返回上一页]
	 * @param  {[字符串]} num [传入判断的值]
	 * @date 2016.09.30
	 * @auther Lee Chen
	 * demo back();
	 */
	function back(num, time) {
		if (time) {
			setTimeout(function () {
				window.history.go((num || -1));
			}, time);
		} else {
			window.history.go((num || -1));
		}
	}

	/*
	 * 31
	 * [decimalSize 获取元素的CSS高度或宽度属性，取数字并四舍五入]
	 * @param  {[字符串]} num [传入判断的值]
	 * @date 2016.09.30
	 * @auther Lee Chen
	 * demo decimalSize();
	 */
	function decimalSize(ele, size) {
		(typeof ele == 'string') && (ele = $(ele));
		return decimalRound(Number(ele.css(size).split('px')[0]), 0);
	}

	/*
	 * 32
	 * [sortLetter 抽取对象中的城市和字母数据并按照字幕顺序排序]
	 * @param  {[字符串]} num [传入判断的值]
	 * @date 2016.09.30
	 * @auther Lee Chen
	 * demo 
		sortLetter({
			"F": [
				{
					"id": "150",
					"name": "福州市"
				},
				{
					"id": "2103",
					"name": "抚州市"
				}
			],
			"G": [
				{
					"id": "4281",
					"name": "广州市"
				},
				{
					"id": "1929",
					"name": "赣州市"
				}
			]
		})
	 */
	function sortLetter(obj, judge) {
		var titArr = [];
		var conArr = [];

		if (obj.type == 1) {
			var cityObj = {};
			var letterArr = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
			for (var i = 0; i < letterArr.length; i++) {
				cityObj[letterArr[i]] = {
					letter: letterArr[i],
					name: []
				}
			}
			var titJudge = false;
			var index = 0;
			for (var i = 0; i < obj.letter.length; i++) {
				cityObj[obj.letter[i][obj.prop]].name.push(obj.letter[i]);
			}
			for (var k = 0; k < letterArr.length; k++) {
				if (cityObj[letterArr[k]].name.length) {
					titArr.push(letterArr[k]);
					conArr.push(cityObj[letterArr[k]]);
				}
			}
		} else {
			for (var i in obj) {
				titArr.push(i);
				if (judge) {
					conArr.push(obj[i]);
				} else {
					conArr.push({ // 创建可供输出树形结构的数组
						letter: i,
						name: obj[i]
					});
				}
			}
			
			if (judge) {
				var arrTmp = [];
				conArr = core.bubbleSortSmall(titArr, conArr)[1];
				for (var i = 0; i < conArr.length; i++) {
					for (var j = 0; j < conArr[i].length; j++) {
						arrTmp.push(conArr[i][j]);
					}
				}
				return arrTmp
			}
		}
		return core.bubbleSortSmall(titArr, conArr);
	}

	/*
	 * 33
	 * [securityCodeJudge 判断输入的是否数字验证码，可指定位数，默认6位]
	 * @param  {[字符串]} num [传入判断的值]
	 * @date 2016.09.20
	 * @auther Lee Chen
	 * demo securityCodeJudge(123456, 6);
	 */
	function securityCodeJudge(str, digit) {
		digit = digit || 6;
		str = str.toString();
		return str.match('\\d{' + digit + '}');
	}

	/*
	 * 34
	 * [getCookie 利用正则获取cookie的值]
	 * @param  {[字符串]} str [需要获取的属性名]
	 * @date 2016.12.19
	 * @auther Lee Chen
	 * demo getCookie(123456, 6);
	 */
	function getCookie(str) {
		var cookie = document.cookie + ';';
		if ($.isArray(str)) {
			var result = [];
			for (var i = 0; i < str.length; i++) {
				result[i] = cookie.match(str[i] + '=([^;]*)') && cookie.match(str[i] + '=([^;]*)')[1];
			}
			return result
		} else {
			return cookie.match(str + '=([^;]*)') && cookie.match(str + '=([^;]*)')[1];
		}
	}

	/*
	 * 35
	 * [setCookie 存储cookie的值]
	 * @param  {[字符串或数组]} str [需要设置的属性名]
	 * @param  {[数字或数组]} time [需要设置的属性名]
	 * @date 2016.12.19
	 * @auther Lee Chen
	 * demo getCookie(123456, 6);
	 */
	function setCookie(str, time) {
		var cookie = document.cookie + ';';
		if ($.isArray(str)) {
			if (typeof time == 'number') {
				var date = new Date();
				date.setTime(date.getTime() + time);
				for (var i = 0; i < str.length; i++) {
					document.cookie = str[i] + ';expires=' + date.toGMTString();
				}
			} else if ($.isArray(time)) {
				var date = [];
				for (var i = 0; i < str.length; i++) {
					date[i] = new Date();
					date[i].setTime(date[i].getTime() + time[i]);
					document.cookie = str[i] + ';expires=' + date[i].toGMTString();
				}
			} else {
				for (var i = 0; i < str.length; i++) {
					document.cookie = str[i];
				}
			}
		} else {
			if (typeof time == 'number') {
				var date = new Date();
				date.setTime(date.getTime() + time);
				document.cookie = str + ';expires=' + date.toGMTString();
			} else {
				document.cookie = str;
			}
		}
	}

	/*
	 * 36
	 * [uuid 生成uuid随机编码]
	 * @date 2017.01.09
	 * @auther Lee Chen
	 * demo uuid();
	 */
	function uuid() {
		var d = new Date().getTime();
		var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
			var r = (d + Math.random()*16)%16 | 0;
			d = Math.floor(d/16);
			return (c=='x' ? r : (r&0x3|0x8)).toString(16);
		});
		return uuid;
	}

	/*
	 * 37
	 * [dateDetail 根据当前时间，转换为js可用的date对象，并返回年、月、日、周几、小时、分钟、秒]
	 * @date 2017.01.09
	 * @auther Lee Chen
	 * demo dateDetail();
	 */
	function dateDetail(setTime) {
		var date = (setTime ? new Date(setTime) : new Date());
		return {
			year: date.getFullYear(),		// 从 Date 对象以四位数字返回年份。
			mon: doubleDigit(date.getMonth() + 1),		// 从 Date 对象返回月份 (0 ~ 11)
			day: doubleDigit(date.getDay()),		// 从 Date 对象返回一周中的某一天 (0 ~ 6)。
			date: doubleDigit(date.getDate()),		// 从 Date 对象返回一个月中的某一天 (1 ~ 31)。
			hour: doubleDigit(date.getHours()),		// 返回 Date 对象的小时 (0 ~ 23)。
			min: doubleDigit(date.getMinutes()),		// 返回 Date 对象的分钟 (0 ~ 59)。
			sec: doubleDigit(date.getSeconds()),		// 返回 Date 对象的秒数 (0 ~ 59)。
			hm: doubleDigit(date.getHours()) + ':' + doubleDigit(date.getMinutes()),
			hms: doubleDigit(date.getHours()) + ':' + doubleDigit(date.getMinutes()) + ':' + doubleDigit(date.getSeconds()),
			ms: doubleDigit(date.getMinutes()) + ':' + doubleDigit(date.getSeconds()),
			ymd: date.getFullYear() + '.' + doubleDigit(date.getMonth() + 1) + '.' + doubleDigit(date.getDate()),
			ymd2: date.getFullYear() + '-' + doubleDigit(date.getMonth() + 1) + '-' + doubleDigit(date.getDate()),
			utcYear: date.getUTCFullYear(),		// 从 Date 对象以四位数字返回年份。
			utcMon: doubleDigit(date.getUTCMonth()) + 1,		// 从 Date 对象返回月份 (0 ~ 11)。
			utcDay: doubleDigit(date.getDay() + 1),		// 从 Date 对象返回一周中的某一天 (0 ~ 6)。
			utcDate: doubleDigit(date.getUTCDate()),		// 从 Date 对象返回一个月中的某一天 (1 ~ 31)。
			utcHour: doubleDigit(date.getUTCHours()),		// 返回 Date 对象的小时 (0 ~ 23)。
			utcMin: doubleDigit(date.getUTCMinutes()),		// 返回 Date 对象的分钟 (0 ~ 59)。
			utcSec: doubleDigit(date.getUTCSeconds()),		// 返回 Date 对象的秒数 (0 ~ 59)。
			utcYmd: date.getUTCFullYear() + '.' + doubleDigit(date.getUTCMonth() + 1) + '.' + doubleDigit(date.getUTCDate()),
			utcYmd2: date.getUTCFullYear() + '-' + doubleDigit(date.getUTCMonth() + 1) + '-' + doubleDigit(date.getUTCDate()),
			utcHms: doubleDigit(date.getUTCHours()) + ':' + doubleDigit(date.getUTCMinutes()) + ':' + doubleDigit(date.getUTCSeconds()),
			utcHm: doubleDigit(date.getUTCHours()) + ':' + doubleDigit(date.getUTCMinutes()),
			utcMs: doubleDigit(date.getUTCMinutes()) + ':' + doubleDigit(date.getUTCSeconds()),
			getTime: date.getTime()
		};
	}

	/*
	 * 38
	 * [vueProp 根据对象的属性名，创建Vue中使用的初始化属性，默认值为空]
	 * @date 2017.02.21
	 * @auther Lee Chen
	 * demo core.vueProp(data.list[0]);
	 */
	function vueProp(obj) {
		var str = '';
		for (var i in obj) {
			str += i + ": '',\n";
		}
		str = subString(str);
		console.log(str)
	}

	/*
	 * 39
	 * [listJudge 分别对比传入数组的值，如果有值等于目标值，则返回true]
	 * @date 2017.02.27
	 * @auther Lee Chen
	 * demo core.listJudge(1, arr);
	 */
	function listJudge(target, arr) {
		for (var i = 0; i < arr.length; i++) {
			if (target == arr[i]) {
				return true;
			}
		}
	}

	/*
	 * 40
	 * [pwJudge 判断是否为正确密码，默认字母加数字]
	 * @date 2017.03.23
	 * @auther Lee Chen
	 * demo core.pwJudge(1111111);
	 */
	function pwJudge(str, type) {
		if (type) {
			if (type == 'num') {
				if (str.toString().match(/^\d{6}$/)) {
					return true;
				}
			}
		} else {
			if (str.toString().match(/[0-9a-zA-Z]{6,16}/)) {
				return true;
			}
		}
	}

	/*
	 * 41
	 * [arrToStr 将数组的值转换为字符串1,2,3形式]
	 * @date 2017.03.25
	 * @auther Lee Chen
	 * demo core.arrToStr([1, 2, 3]);
	 */
	function arrToStr(arr) {
		var str = '';
		for (var i = 0; i < arr.length; i++) {
			str += arr[i] + ',';
		}
		return subString(str);
	}

	/*
	 * 42
	 * [delEmptyArr 将数组中的空值去除]
	 * @date 2017.03.29
	 * @auther Lee Chen
	 * demo core.delEmptyArr(['', '1', '2', '', '3', '4', '', '5', '6', '']);
	 */
	function delEmptyArr(arr) {
		var emptyIndex = [];
		for (var i = 0; i < arr.length; i++) {
			if (!arr[i]) {
				emptyIndex.push(i);
			}
		}
		for (var i = 0; i < emptyIndex.length; i++) {
			arr.splice(emptyIndex[i], 1);
			emptyIndex[i + 1] && (emptyIndex[i + 1] = emptyIndex[i + 1] - i - 1);
		}
		return arr;
	}

	/*
	 * 43
	 * [arrJudge 遍历数组的值，当值等于设定值时，返回true]
	 * @date 2017.03.31
	 * @auther Lee Chen
	 * demo core.arrJudge([1, 2, 3]);
	 */
	function arrJudge(arr, data) {
		for (var i = 0; i < arr.length; i++) {
			if (arr[i] == data) {
				return true;
			}
		}
	}

	/*
	 * 44
	 * [strLen 获取字符串长度，英文及英文标点为1，中文字符为2]
	 * @date 2017.04.08
	 * @auther Lee Chen
	 * demo core.strLen('陈立');
	 */
	function strLen(str) {
		var len = 0;	
		for (var i = 0; i < str.length; i++) {	
			if (str.charCodeAt(i) > 127) {	
				len += 2;	
			} else {	
				len++;	
			}	
		}	
		return len; 
	}

	/*
	 * 45
	 * [constellation 根据传入的月份和日期，判断星座]
	 * @date 2017.04.21
	 * @auther Lee Chen
	 * demo core.constellation(3, 22);
	 */
	function constellation(month, date) {
		var star = '',
			month = Number(month),
			date = Number(date);

		if (month == 1 && date >= 20 || month == 2 && date <= 18) {
			star = "水瓶";
		}
		if (month == 2 && date >= 19 || month == 3 && date <= 20) {
			star = "双鱼";
		}
		if (month == 3 && date >= 21 || month == 4 && date <= 19) {
			star = "白羊";
		}
		if (month == 4 && date >= 20 || month == 5 && date <= 20) {
			star = "金牛";
		}
		if (month == 5 && date >= 21 || month == 6 && date <= 21) {
			star = "双子";
		}
		if (month == 6 && date >= 22 || month == 7 && date <= 22) {
			star = "巨蟹";
		}
		if (month == 7 && date >= 23 || month == 8 && date <= 22) {
			star = "狮子";
		}
		if (month == 8 && date >= 23 || month == 9 && date <= 22) {
			star = "室女";
		}
		if (month == 9 && date >= 23 || month == 10 && date <= 22) {
			star = "天秤";
		}
		if (month == 10 && date >= 23 || month == 11 && date <= 21) {
			star = "天蝎";
		}
		if (month == 11 && date >= 22 || month == 12 && date <= 21) {
			star = "人马";
		}
		if (month == 12 && date >= 22 || month == 1 && date <= 19) {
			star = "摩羯";
		}

		if (star) {
			return star;
		} else {
			console.error('星座获取错误，请检查日期是否正确');
		}
	}

	/*
	 * 46
	 * [strToDateDetail 从时间字符串中提取时间，输出dateDetail]
	 * @date 2017.04.21
	 * @auther Lee Chen
	 * demo core.strToDateDetail('2017-04-22 05:00:00');
	 */
	function strToDateDetail(str, type, dateType) {
		var result = [],
			date = null;
		if (type == 1) {		// 匹配类型2017-04-22 05:00:00
			result = str.match(/(\d*)-(\d*)-(\d*)\s(\d*):(\d*):(\d*)/);
			date = new Date(Number(result[1]), Number(result[2]) - 1, Number(result[3]), Number(result[4]), Number(result[5]), Number(result[6]));
		} else {
			console.error('请选择type后再进行验证');
		}
		if (dateType == 'date') {
			return date;
		} else {
			return dateDetail(date); 
		}
	}

	/*
	 * 47
	 * [sameArr 输出一个具有相同值的数组]
	 * @date 2017.05.07
	 * @auther Lee Chen
	 * demo core.sameArr(true, 3);
	 */
	function sameArr(data, num) {
		var arr = [];

		for (var i = 0; i < num.length; i++) {
			arr[i].push(data);
		}

		return arr;
	}

	/************************** Form部分 **************************/
	/*
	 * 1
	 * [keyCodeJudgeStr 判断在文本框输入的按键是否为非字符，如果是，则返回false，否则返回true]
	 * @param  {[字符串]} keyCode [按键输入的编码]
	 * @date 2016.06.02
	 * @auther Lee Chen
	 * demo keyCodeJudgeStr(key.keyCode)
	 */
	 function keyCodeJudgeStr (keyCode) {
	 	var uselessKeyCode = [27, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 9, 20, 16, 17, 18, 91, 93, 13, 8, 145, 19, 45, 46, 36, 35, 33, 34, 144];		// 键盘上无法实际输入值的按键编码
		var judge = true;
		for (var i = 0; i < uselessKeyCode.length; i++) {
			if (keyCode == uselessKeyCode[i]) {		// 如果输入的按键为无法实际输入值的按键，则返回false
				judge = false;
			}
		}
		return judge;
	}

	/*
	 * 2
	 * [keyCodeJudgeNum 判断在文本框输入的按键是否为数字，如果是，则返回true，否则返回false]
	 * @param  {[字符串]} keyCode [按键输入的编码]
	 * @date 2016.06.02
	 * @auther Lee Chen
	 * demo keyCodeJudgeNum(key.keyCode)
	 */
	 function keyCodeJudgeNum (keyCode) {
	 	var uselessKeyCode = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105];		// 键盘上所有数字键对应的编码，包括小键盘
		var judge = false;
		for (var i = 0; i < uselessKeyCode.length; i++) {
			if (keyCode == uselessKeyCode[i]) {		// 当输入的按键为数字时，返回true
				judge = true;
			}
		}
		return judge;
	}

	/*
	 * 3
	 * [inputPlaceholder JS模拟placeholder效果，当输入有效字符时，隐藏placeholder]
	 * @param  {[数组]} inputArr [传入input输入框]
	 * @param  {[数组]} inputArr [传入用作placeholder的标签]
	 * @param  {[布尔值]} judge [为true则输入字符串和数字都有效，false则只有输入数字有效]
	 * @date 2016.06.02
	 * @auther Lee Chen
	 * demo inputPlaceholder([$rollPoint, $rollSecurity, $exchangePoint, $exchangeSecurity, $tbcPWRoll], [$rollPoint.siblings('label'), $rollSecurity.siblings('label'), $exchangePoint.siblings('label'), $exchangeSecurity.siblings('label'), $tbcPWRoll.siblings('label')])
	 */

	function inputPlaceholder(inputArr, hintArr, judge) {
		for (var i = 0; i < inputArr.length; i++) {		// 使用for循环为输入框数组添加事件
			inputArr[i].on('keydown', function (num) {		// 使用闭包，存储当前输入框的索引值
				return function (key) {
					var key = key || window.event;

					if (judge) {
						var judgeFun = keyCodeJudgeStr;
					} else {
						var judgeFun = keyCodeJudgeNum;
					}

					if (judgeFun(key.keyCode))  {		// 如果键盘按下的按键是有效值（包括字母和数字），即清除placeholder
						hintArr[num].css({
							display: 'none'
						});
					}
				}
			}(i));

			inputArr[i].on('keyup', function (num) {		// 使用闭包，存储当前输入框的索引值
				return function () {
					if (inputArr[num].val() == '') {		// 如果输入框值为空，则显示placeholder
						hintArr[num].css({
							display: 'block'
						});
					}
				}
			}(i));

			inputArr[i].on('blur', function (num) {		// 使用闭包，存储当前输入框的索引值
				return function () {
					if (inputArr[num].val() == '') {		// 如果失焦时输入框值为空，则显示placeholder
						hintArr[num].css({
							display: 'block'
						});
					}
				}
			}(i));
		}
	}

	/*
	 * 4
	 * [inputPosIntJudge 可选择判断文本框输入的值是否为数字、数字和字符串、字符串，若为非法输入，则返回true，并可设置当非法输入时，清除非非法字符]
	 * @param  {[对象]} inputObj [定义函数运行所需的参数]
	 * @date 2016.06.12
	 * @auther Lee Chen
	 * demo 
	 * inputPosIntJudge({
			inputEle: $rollPoint,		// 获取输入内容的元素
			hintEle: $rollHint,		// 提示错误信息的元素
			spaceStr: '请输入正整数',		// 输入为空格的元素
			emptyStr: '请输入积分',		// 输入为空时提示
			NaNStr: '请输入正整数',		// 输入不符合regStr正则时提示
			type: 'number',		// 判断字符是否为数字
			clear: true		// 清除非法输入的字符
		}
	 */
	
	function inputPosIntJudge(inputObj) {
		if (inputObj.type == 'number') {
			var regStr = /\D+/gi;		// 判断是否不为数字的正则，\D表示[^0-9]
		} else if (inputObj.type == 'numStr_') {
			var regStr = /\W+/gi;		// 判断是否不为数字和字母的正则，\W表示[^0-9_a-zA-Z]，包括下划线
		} else if (inputObj.type == 'numStr') {
			var regStr = /[^0-9a-zA-Z]+/gi;		// 判断是否不为数字和字母的正则，\W表示[^0-9_a-zA-Z]
		} else if (inputObj.type == 'string') {
			var regStr = /[^a-z]+/gi;		// 判断是否不为字母的正则
		}
		var regSpace = /[ ]+/;		// 判断是否为空格的正则
		var inputVal = inputObj.inputEle.val();		// 获取输入框的数据

		if (inputVal == '') {		// 输入框数据为空时
			if (inputObj.hintEle) {
				inputObj.hintEle.html(inputObj.emptyStr);		// 输入框数据为空时的提示语
			}
			
			if (inputObj.callback) {		// 回调函数
				inputObj.callback();
			}
			return true;
		} else if (inputVal.match(regSpace)) {		// 输入框数据为空格，这段判断其实和regStr的判断重复，regStr也可判断出有空格的状况
			if (inputObj.clear) {		// 是否清除输入错误的数据
				inputObj.inputEle.val(inputVal.replace(regSpace, ''));
			}
			if (inputObj.hintEle) {
				inputObj.hintEle.html(inputObj.spaceStr);		// 输入框数据为空格时的提示语
			}

			if (inputObj.callback) {		// 回调函数
				inputObj.callback();
			}
			return true;
		} else if (inputVal.match(regStr)) {		// 输入框数据为非数字
			if (inputObj.clear) {		// 是否清除输入错误的数据
				inputObj.inputEle.val(inputVal.replace(regStr, ''));
			}
			if (inputObj.hintEle) {
				inputObj.hintEle.html(inputObj.NaNStr);		// 输入框数据为数字时的提示语
			}

			if (inputObj.callback) {		// 回调函数
				inputObj.callback();
			}
			return true;
		}
	}

	/*
	 * 5
	 * [setArrAttr 批量判断数组中元素的某个属性是否定义，如果未定义则根据事件添加属性值，可通过另一个事件清除该属性的值]
	 * @param  {[字符串]} inputEle [需要显示的登记名称]
	 * @param  {[数字]} hintEle [用于计算等级的数据]
	 * @param  {[数字]} hintStr [每个等级之间的差值]
	 * @date 2016.06.02
	 * @auther Lee Chen
	 * demo 
		// 输入框聚焦时，批量添加属性，失焦时清除属性
		setArrAttr({
			eleArr: [$rollPoint, $rollSecurity, $exchangePoint, $exchangeSecurity],
			eventAdd: 'focus',
			judgeAttr: 'type',
			setAttr: 'text',
			eventRemove: 'blur'
		})
	 */
	function setArrAttr(setAttrObj) {
		for (var i = 0; i < setAttrObj.eleArr.length; i++) {
			setAttrObj.eleArr[i].on(setAttrObj.eventAdd, function () {		// 通过setAttrObj.eventAdd事件触发添加属性
				var $this = $(this);
				if ($this.attr(setAttrObj.judgeAttr) == undefined) {		// 如果属性不存在，则添加
					$this.attr(setAttrObj.judgeAttr, setAttrObj.setAttr);
				}
			});
			if (setAttrObj.eventRemove) {
				setAttrObj.eleArr[i].on(setAttrObj.eventRemove, function () {		// 通过setAttrObj.eventAdd事件触发清除属性
					var $this = $(this);
					if ($this.attr(setAttrObj.judgeAttr)) {		// 如果属性存在则清除
						$this.removeAttr(setAttrObj.judgeAttr);
					}
				})
			}
		}
	}

	/*
	 * 6
	 * [copyInput 
	 		1. 针对IE9+、FF、Chrome，使用ZeroClipboard.js插件实现将input输入框内容复制到剪切板功能，需要引入ZeroClipboard.js
	 		2. 针对IE8-，使用window.clipboardData.setData方法调用剪切板复制]
	 * @param  {[对象]} copyEle [传入的对象，其中定义各种参数，该方法兼容IE9+]
		copyEle的创建示例
	 	// 定义构造函数，用于传递实现复制所需标签
		function CopyEle() {
			this.$copyBtn = $('.header-outer .header-box .party-show .play-box .play-show .share-box form .input-box strong'); // 获取点击开始复制的按钮
			this.$copyEle = $('.header-outer .header-box .party-show .play-box .play-show .share-box form .input-box input'); // 获取需要复制的输入框
		}
	 * @date 2016.05.13
	 * @auther Lee Chen
	 * @HTML
		<!-- 输入框的box -->
		<div class="input-box clearfix">
			<!-- 要复制文字的输入框 -->
			<input type="text" name="" value="">
			<!-- 点击复制的按钮 -->
			<strong>复制专属链接</strong>
		</div>
	 * demo copyInput(copyEle);
	 	// 将实例化对象传参后，调用
	 	copyInput(new CopyEle())();
	 */

	function copyInput(copyEle) {
		var $copyBtn = copyEle.$copyBtn;		// 点击复制按钮
		var $copyEle = copyEle.$copyEle;		// 复制内容的标签

		return function copyVal() {
			// 判断IE版本所用参数
			var browser = navigator.appName;
			var b_version = navigator.appVersion;
			var version = b_version.split(";");
			if (version[1]) {		// 如果version[1]存在，则赋值，放置火狐中出错
				var trim_Version = version[1].replace(/[ ]/g, "");
			}
			// 判断IE版本是否为IE8-
			if ((browser == "Microsoft Internet Explorer" && trim_Version == "MSIE6.0") || (browser == "Microsoft Internet Explorer" && trim_Version == "MSIE7.0") || (browser == "Microsoft Internet Explorer" && trim_Version == "MSIE8.0")) {
				$copyBtn.on('click', function () {		// IE8-采用window.clipboardData.setData方法调用剪切板复制
					if (window.clipboardData.setData('text', $copyEle.val())) {
						alert('已复制到剪贴板');
					}
				})
			} else {
				var clip = new ZeroClipboard($copyBtn);		// 实例化一个ZeroClipboard对象

				clip.on('ready', function(){		// 当swf文件载入时，绑定mouseup事件
					$copyBtn.on('mouseup', function () {		// 此处使用click事件，需要点击两次标签才能完成复制动作，所以使用mouseup事件进行操作
						clip.setText($copyEle.val());		// 使用setText方法
						clip.on('aftercopy', function () {
							alert('已复制到剪贴板');
						})
					})
				});
			}
		}
	}

	/*
	 * 7
	 * [vForm 简易表单验证插件，初始化之后以数组形式传入验证正则或函数，在函数外部使用vForm.judge属性判断验证是否通过]
	 * @param  {[对象]} copyEle [传入的对象，其中定义各种参数，该方法兼容IE9+]
	 * @date 2016.09.01
	 * @auther Lee Chen
	 * demo copyInput(copyEle);
	 	// 初始化验证函数
	 	core.vForm();
	 	// 通过rule函数提供验证方式
	 	vForm.rule([{
			ele: '#phoneNum',
			verify: core.phoneJudge,
			error: '请输入正确手机号'
		}], {
			submit: 'body .wrap .confirm-order form .pay em',
			ajax: {
				url: '../test.php?query='
			}
		})
	 */
	function vForm() {
		function VForm() {
			this.judge = false;
			this.inputJudge = [];
			this.arr = [];
			this.obj = {};
			this.len = 0;

			// if (!window.hint) {
			// 	// 初始化弹窗对象
			// 	window.hint = mobileHint();
			// }
		}

		VForm.prototype.rule = function(arr, obj){
			var _this = this;
			this.arr = arr;
			this.obj = obj;
			if (obj.ajax) {
				var urlTmp = obj.ajax.url;
			}
			this.len = arr.length;

			for (var i = 0; i < this.len; i++) {
			 	this.inputJudge[i] = false;
				$(arr[i].ele).on('blur', function (num) {
					return function () {
						_this.verify(num);
					}
				}(i));
			}
			if (obj.submit) {
				$(obj.submit).on('tap', function () {
					var $this = $(this);

					_this.verifyAll();
					
					if (_this.judge) {
						if (obj.subFun) {
							obj.subFun($this);
						}
						if (_this.obj.ajax) {
							if (obj.beforeAjax) {
								obj.beforeAjax($this);
							}

							var ajaxObj = _this.obj.ajax;
							ajaxObj.url = urlTmp + objToAjaxObj(getAjaxObj());
							ajax(ajaxObj);
							if (obj.afterAjax) {
								obj.afterAjax($this);
							}
						}
					}
				})
			}
		};

		VForm.prototype.verify = function (index) {
			if (typeof this.arr[index].verify == 'object') {
				if ($this.val().match(this.arr[index].verify)) {
					this.inputJudge[index] = true;
				} else {
					this.inputJudge[index] = false;
				}
			} else if (typeof this.arr[index].verify == 'function') {
				if (this.arr[index].verify($(this.arr[index].ele).val())) {
					this.inputJudge[index] = true;
					if (this.arr[index].correct) {
						// hint.show(this.arr[index].correct);
						layerHint(this.arr[index].correct);
					}
					if (this.arr[index].correctCB) {
						this.arr[index].correctCB();
					}
				} else {
					this.inputJudge[index] = false;
					if (this.arr[index].error) {
						// hint.show(this.arr[index].error);
						layerHint(this.arr[index].error);
					}
					if (this.arr[index].errorCB) {
						this.arr[index].errorCB();
					}
				}
			}

			if (arrJudge(this.inputJudge)) {		// 如果所有输入框的布尔值都为true
				this.judge = true;
				if (this.obj.judgeTrue) {
					this.obj.judgeTrue();
				}
			} else {
				this.judge = false;
				if (this.obj.judgeFalse) {
					this.obj.judgeFalse();
				}
			}
		};

		VForm.prototype.verifyAll = function(success, fail){
			for (var i = 0; i < this.len; i++) {
				this.verify(i);
				if (this.inputJudge[i] == false) {
					if (fail) {
						fail();
					}
					return false;
				}
			}

			if (success) {
				success();
			}
		};

		window.vForm = new VForm();
	}

}
createCore();
